diff options
Diffstat (limited to 'scripts/lib')
209 files changed, 13746 insertions, 31388 deletions
diff --git a/scripts/lib/argparse_oe.py b/scripts/lib/argparse_oe.py new file mode 100644 index 0000000000..bf6eb17197 --- /dev/null +++ b/scripts/lib/argparse_oe.py @@ -0,0 +1,169 @@ +import sys +import argparse +from collections import defaultdict, OrderedDict + +class ArgumentUsageError(Exception): + """Exception class you can raise (and catch) in order to show the help""" + def __init__(self, message, subcommand=None): + self.message = message + self.subcommand = subcommand + +class ArgumentParser(argparse.ArgumentParser): + """Our own version of argparse's ArgumentParser""" + def __init__(self, *args, **kwargs): + kwargs.setdefault('formatter_class', OeHelpFormatter) + self._subparser_groups = OrderedDict() + super(ArgumentParser, self).__init__(*args, **kwargs) + self._positionals.title = 'arguments' + self._optionals.title = 'options' + + def error(self, message): + """error(message: string) + + Prints a help message incorporating the message to stderr and + exits. + """ + self._print_message('%s: error: %s\n' % (self.prog, message), sys.stderr) + self.print_help(sys.stderr) + sys.exit(2) + + def error_subcommand(self, message, subcommand): + if subcommand: + action = self._get_subparser_action() + try: + subparser = action._name_parser_map[subcommand] + except KeyError: + self.error('no subparser for name "%s"' % subcommand) + else: + subparser.error(message) + + self.error(message) + + def add_subparsers(self, *args, **kwargs): + if 'dest' not in kwargs: + kwargs['dest'] = '_subparser_name' + + ret = super(ArgumentParser, self).add_subparsers(*args, **kwargs) + # Need a way of accessing the parent parser + ret._parent_parser = self + # Ensure our class gets instantiated + ret._parser_class = ArgumentSubParser + # Hacky way of adding a method to the subparsers object + ret.add_subparser_group = self.add_subparser_group + return ret + + def add_subparser_group(self, groupname, groupdesc, order=0): + self._subparser_groups[groupname] = (groupdesc, order) + + def parse_args(self, args=None, namespace=None): + """Parse arguments, using the correct subparser to show the error.""" + args, argv = self.parse_known_args(args, namespace) + if argv: + message = 'unrecognized arguments: %s' % ' '.join(argv) + if self._subparsers: + subparser = self._get_subparser(args) + subparser.error(message) + else: + self.error(message) + sys.exit(2) + return args + + def _get_subparser(self, args): + action = self._get_subparser_action() + if action.dest == argparse.SUPPRESS: + self.error('cannot get subparser, the subparser action dest is suppressed') + + name = getattr(args, action.dest) + try: + return action._name_parser_map[name] + except KeyError: + self.error('no subparser for name "%s"' % name) + + def _get_subparser_action(self): + if not self._subparsers: + self.error('cannot return the subparser action, no subparsers added') + + for action in self._subparsers._group_actions: + if isinstance(action, argparse._SubParsersAction): + return action + + +class ArgumentSubParser(ArgumentParser): + def __init__(self, *args, **kwargs): + if 'group' in kwargs: + self._group = kwargs.pop('group') + if 'order' in kwargs: + self._order = kwargs.pop('order') + super(ArgumentSubParser, self).__init__(*args, **kwargs) + + def parse_known_args(self, args=None, namespace=None): + # This works around argparse not handling optional positional arguments being + # intermixed with other options. A pretty horrible hack, but we're not left + # with much choice given that the bug in argparse exists and it's difficult + # to subclass. + # Borrowed from http://stackoverflow.com/questions/20165843/argparse-how-to-handle-variable-number-of-arguments-nargs + # with an extra workaround (in format_help() below) for the positional + # arguments disappearing from the --help output, as well as structural tweaks. + # Originally simplified from http://bugs.python.org/file30204/test_intermixed.py + positionals = self._get_positional_actions() + for action in positionals: + # deactivate positionals + action.save_nargs = action.nargs + action.nargs = 0 + + namespace, remaining_args = super(ArgumentSubParser, self).parse_known_args(args, namespace) + for action in positionals: + # remove the empty positional values from namespace + if hasattr(namespace, action.dest): + delattr(namespace, action.dest) + for action in positionals: + action.nargs = action.save_nargs + # parse positionals + namespace, extras = super(ArgumentSubParser, self).parse_known_args(remaining_args, namespace) + return namespace, extras + + def format_help(self): + # Quick, restore the positionals! + positionals = self._get_positional_actions() + for action in positionals: + if hasattr(action, 'save_nargs'): + action.nargs = action.save_nargs + return super(ArgumentParser, self).format_help() + + +class OeHelpFormatter(argparse.HelpFormatter): + def _format_action(self, action): + if hasattr(action, '_get_subactions'): + # subcommands list + groupmap = defaultdict(list) + ordermap = {} + subparser_groups = action._parent_parser._subparser_groups + groups = sorted(subparser_groups.keys(), key=lambda item: subparser_groups[item][1], reverse=True) + for subaction in self._iter_indented_subactions(action): + parser = action._name_parser_map[subaction.dest] + group = getattr(parser, '_group', None) + groupmap[group].append(subaction) + if group not in groups: + groups.append(group) + order = getattr(parser, '_order', 0) + ordermap[subaction.dest] = order + + lines = [] + if len(groupmap) > 1: + groupindent = ' ' + else: + groupindent = '' + for group in groups: + subactions = groupmap[group] + if not subactions: + continue + if groupindent: + if not group: + group = 'other' + groupdesc = subparser_groups.get(group, (group, 0))[0] + lines.append(' %s:' % groupdesc) + for subaction in sorted(subactions, key=lambda item: ordermap[item.dest], reverse=True): + lines.append('%s%s' % (groupindent, self._format_action(subaction).rstrip())) + return '\n'.join(lines) + else: + return super(OeHelpFormatter, self)._format_action(action) diff --git a/scripts/lib/build_perf/__init__.py b/scripts/lib/build_perf/__init__.py new file mode 100644 index 0000000000..1f8b729078 --- /dev/null +++ b/scripts/lib/build_perf/__init__.py @@ -0,0 +1,31 @@ +# +# Copyright (c) 2017, Intel Corporation. +# +# This program is free software; you can redistribute it and/or modify it +# under the terms and conditions of the GNU General Public License, +# version 2, as published by the Free Software Foundation. +# +# This program is distributed in the hope it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for +# more details. +# +"""Build performance test library functions""" + +def print_table(rows, row_fmt=None): + """Print data table""" + if not rows: + return + if not row_fmt: + row_fmt = ['{:{wid}} '] * len(rows[0]) + + # Go through the data to get maximum cell widths + num_cols = len(row_fmt) + col_widths = [0] * num_cols + for row in rows: + for i, val in enumerate(row): + col_widths[i] = max(col_widths[i], len(str(val))) + + for row in rows: + print(*[row_fmt[i].format(col, wid=col_widths[i]) for i, col in enumerate(row)]) + diff --git a/scripts/lib/build_perf/html.py b/scripts/lib/build_perf/html.py new file mode 100644 index 0000000000..578bb162ee --- /dev/null +++ b/scripts/lib/build_perf/html.py @@ -0,0 +1,19 @@ +# +# Copyright (c) 2017, Intel Corporation. +# +# This program is free software; you can redistribute it and/or modify it +# under the terms and conditions of the GNU General Public License, +# version 2, as published by the Free Software Foundation. +# +# This program is distributed in the hope it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for +# more details. +# +"""Helper module for HTML reporting""" +from jinja2 import Environment, PackageLoader + + +env = Environment(loader=PackageLoader('build_perf', 'html')) + +template = env.get_template('report.html') diff --git a/scripts/lib/build_perf/html/measurement_chart.html b/scripts/lib/build_perf/html/measurement_chart.html new file mode 100644 index 0000000000..65f1a227ad --- /dev/null +++ b/scripts/lib/build_perf/html/measurement_chart.html @@ -0,0 +1,50 @@ +<script type="text/javascript"> + chartsDrawing += 1; + google.charts.setOnLoadCallback(drawChart_{{ chart_elem_id }}); + function drawChart_{{ chart_elem_id }}() { + var data = new google.visualization.DataTable(); + + // Chart options + var options = { + theme : 'material', + legend: 'none', + hAxis: { format: '', title: 'Commit number', + minValue: {{ chart_opts.haxis.min }}, + maxValue: {{ chart_opts.haxis.max }} }, + {% if measurement.type == 'time' %} + vAxis: { format: 'h:mm:ss' }, + {% else %} + vAxis: { format: '' }, + {% endif %} + pointSize: 5, + chartArea: { left: 80, right: 15 }, + }; + + // Define data columns + data.addColumn('number', 'Commit'); + data.addColumn('{{ measurement.value_type.gv_data_type }}', + '{{ measurement.value_type.quantity }}'); + // Add data rows + data.addRows([ + {% for sample in measurement.samples %} + [{{ sample.commit_num }}, {{ sample.mean.gv_value() }}], + {% endfor %} + ]); + + // Finally, draw the chart + chart_div = document.getElementById('{{ chart_elem_id }}'); + var chart = new google.visualization.LineChart(chart_div); + google.visualization.events.addListener(chart, 'ready', function () { + //chart_div = document.getElementById('{{ chart_elem_id }}'); + //chart_div.innerHTML = '<img src="' + chart.getImageURI() + '">'; + png_div = document.getElementById('{{ chart_elem_id }}_png'); + png_div.outerHTML = '<a id="{{ chart_elem_id }}_png" href="' + chart.getImageURI() + '">PNG</a>'; + console.log("CHART READY: {{ chart_elem_id }}"); + chartsDrawing -= 1; + if (chartsDrawing == 0) + console.log("ALL CHARTS READY"); + }); + chart.draw(data, options); +} +</script> + diff --git a/scripts/lib/build_perf/html/report.html b/scripts/lib/build_perf/html/report.html new file mode 100644 index 0000000000..165cbb811c --- /dev/null +++ b/scripts/lib/build_perf/html/report.html @@ -0,0 +1,206 @@ +<!DOCTYPE html> +<html lang="en"> +<head> +{# Scripts, for visualization#} +<!--START-OF-SCRIPTS--> +<script type="text/javascript" src="https://www.gstatic.com/charts/loader.js"></script> +<script type="text/javascript"> +google.charts.load('current', {'packages':['corechart']}); +var chartsDrawing = 0; +</script> + +{# Render measurement result charts #} +{% for test in test_data %} + {% if test.status == 'SUCCESS' %} + {% for measurement in test.measurements %} + {% set chart_elem_id = test.name + '_' + measurement.name + '_chart' %} + {% include 'measurement_chart.html' %} + {% endfor %} + {% endif %} +{% endfor %} + +<!--END-OF-SCRIPTS--> + +{# Styles #} +<style> +.meta-table { + font-size: 14px; + text-align: left; + border-collapse: collapse; +} +.meta-table tr:nth-child(even){background-color: #f2f2f2} +meta-table th, .meta-table td { + padding: 4px; +} +.summary { + margin: 0; + font-size: 14px; + text-align: left; + border-collapse: collapse; +} +summary th, .meta-table td { + padding: 4px; +} +.measurement { + padding: 8px 0px 8px 8px; + border: 2px solid #f0f0f0; + margin-bottom: 10px; +} +.details { + margin: 0; + font-size: 12px; + text-align: left; + border-collapse: collapse; +} +.details th { + font-weight: normal; + padding-right: 8px; +} +.preformatted { + font-family: monospace; + white-space: pre-wrap; + background-color: #f0f0f0; + margin-left: 10px; +} +hr { + color: #f0f0f0; +} +h2 { + font-size: 20px; + margin-bottom: 0px; + color: #707070; +} +h3 { + font-size: 16px; + margin: 0px; + color: #707070; +} +</style> + +<title>{{ title }}</title> +</head> + +{% macro poky_link(commit) -%} + <a href="http://git.yoctoproject.org/cgit/cgit.cgi/poky/log/?id={{ commit }}">{{ commit[0:11] }}</a> +{%- endmacro %} + +<body><div style="width: 700px"> + {# Test metadata #} + <h2>General</h2> + <hr> + <table class="meta-table" style="width: 100%"> + <tr> + <th></th> + <th>Current commit</th> + <th>Comparing with</th> + </tr> + {% for key, item in metadata.items() %} + <tr> + <th>{{ item.title }}</th> + {%if key == 'commit' %} + <td>{{ poky_link(item.value) }}</td> + <td>{{ poky_link(item.value_old) }}</td> + {% else %} + <td>{{ item.value }}</td> + <td>{{ item.value_old }}</td> + {% endif %} + </tr> + {% endfor %} + </table> + + {# Test result summary #} + <h2>Test result summary</h2> + <hr> + <table class="summary" style="width: 100%"> + {% for test in test_data %} + {% if loop.index is even %} + {% set row_style = 'style="background-color: #f2f2f2"' %} + {% else %} + {% set row_style = 'style="background-color: #ffffff"' %} + {% endif %} + <tr {{ row_style }}><td>{{ test.name }}: {{ test.description }}</td> + {% if test.status == 'SUCCESS' %} + {% for measurement in test.measurements %} + {# add empty cell in place of the test name#} + {% if loop.index > 1 %}<td></td>{% endif %} + {% if measurement.absdiff > 0 %} + {% set result_style = "color: red" %} + {% elif measurement.absdiff == measurement.absdiff %} + {% set result_style = "color: green" %} + {% else %} + {% set result_style = "color: orange" %} + {%endif %} + <td>{{ measurement.description }}</td> + <td style="font-weight: bold">{{ measurement.value.mean }}</td> + <td style="{{ result_style }}">{{ measurement.absdiff_str }}</td> + <td style="{{ result_style }}">{{ measurement.reldiff }}</td> + </tr><tr {{ row_style }}> + {% endfor %} + {% else %} + <td style="font-weight: bold; color: red;">{{test.status }}</td> + <td></td> <td></td> <td></td> <td></td> + {% endif %} + </tr> + {% endfor %} + </table> + + {# Detailed test results #} + {% for test in test_data %} + <h2>{{ test.name }}: {{ test.description }}</h2> + <hr> + {% if test.status == 'SUCCESS' %} + {% for measurement in test.measurements %} + <div class="measurement"> + <h3>{{ measurement.description }}</h3> + <div style="font-weight:bold;"> + <span style="font-size: 23px;">{{ measurement.value.mean }}</span> + <span style="font-size: 20px; margin-left: 12px"> + {% if measurement.absdiff > 0 %} + <span style="color: red"> + {% elif measurement.absdiff == measurement.absdiff %} + <span style="color: green"> + {% else %} + <span style="color: orange"> + {% endif %} + {{ measurement.absdiff_str }} ({{measurement.reldiff}}) + </span></span> + </div> + <table style="width: 100%"> + <tr> + <td style="width: 75%"> + {# Linechart #} + <div id="{{ test.name }}_{{ measurement.name }}_chart"></div> + </td> + <td> + {# Measurement statistics #} + <table class="details"> + <tr> + <th>Test runs</th><td>{{ measurement.value.sample_cnt }}</td> + </tr><tr> + <th>-/+</th><td>-{{ measurement.value.minus }} / +{{ measurement.value.plus }}</td> + </tr><tr> + <th>Min</th><td>{{ measurement.value.min }}</td> + </tr><tr> + <th>Max</th><td>{{ measurement.value.max }}</td> + </tr><tr> + <th>Stdev</th><td>{{ measurement.value.stdev }}</td> + </tr><tr> + <th><div id="{{ test.name }}_{{ measurement.name }}_chart_png"></div></th> + </tr> + </table> + </td> + </tr> + </table> + </div> + {% endfor %} + {# Unsuccessful test #} + {% else %} + <span style="font-size: 150%; font-weight: bold; color: red;">{{ test.status }} + {% if test.err_type %}<span style="font-size: 75%; font-weight: normal">({{ test.err_type }})</span>{% endif %} + </span> + <div class="preformatted">{{ test.message }}</div> + {% endif %} + {% endfor %} +</div></body> +</html> + diff --git a/scripts/lib/build_perf/report.py b/scripts/lib/build_perf/report.py new file mode 100644 index 0000000000..eb00ccca2d --- /dev/null +++ b/scripts/lib/build_perf/report.py @@ -0,0 +1,342 @@ +# +# Copyright (c) 2017, Intel Corporation. +# +# This program is free software; you can redistribute it and/or modify it +# under the terms and conditions of the GNU General Public License, +# version 2, as published by the Free Software Foundation. +# +# This program is distributed in the hope it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for +# more details. +# +"""Handling of build perf test reports""" +from collections import OrderedDict, Mapping +from datetime import datetime, timezone +from numbers import Number +from statistics import mean, stdev, variance + + +def isofmt_to_timestamp(string): + """Convert timestamp string in ISO 8601 format into unix timestamp""" + if '.' in string: + dt = datetime.strptime(string, '%Y-%m-%dT%H:%M:%S.%f') + else: + dt = datetime.strptime(string, '%Y-%m-%dT%H:%M:%S') + return dt.replace(tzinfo=timezone.utc).timestamp() + + +def metadata_xml_to_json(elem): + """Convert metadata xml into JSON format""" + assert elem.tag == 'metadata', "Invalid metadata file format" + + def _xml_to_json(elem): + """Convert xml element to JSON object""" + out = OrderedDict() + for child in elem.getchildren(): + key = child.attrib.get('name', child.tag) + if len(child): + out[key] = _xml_to_json(child) + else: + out[key] = child.text + return out + return _xml_to_json(elem) + + +def results_xml_to_json(elem): + """Convert results xml into JSON format""" + rusage_fields = ('ru_utime', 'ru_stime', 'ru_maxrss', 'ru_minflt', + 'ru_majflt', 'ru_inblock', 'ru_oublock', 'ru_nvcsw', + 'ru_nivcsw') + iostat_fields = ('rchar', 'wchar', 'syscr', 'syscw', 'read_bytes', + 'write_bytes', 'cancelled_write_bytes') + + def _read_measurement(elem): + """Convert measurement to JSON""" + data = OrderedDict() + data['type'] = elem.tag + data['name'] = elem.attrib['name'] + data['legend'] = elem.attrib['legend'] + values = OrderedDict() + + # SYSRES measurement + if elem.tag == 'sysres': + for subel in elem: + if subel.tag == 'time': + values['start_time'] = isofmt_to_timestamp(subel.attrib['timestamp']) + values['elapsed_time'] = float(subel.text) + elif subel.tag == 'rusage': + rusage = OrderedDict() + for field in rusage_fields: + if 'time' in field: + rusage[field] = float(subel.attrib[field]) + else: + rusage[field] = int(subel.attrib[field]) + values['rusage'] = rusage + elif subel.tag == 'iostat': + values['iostat'] = OrderedDict([(f, int(subel.attrib[f])) + for f in iostat_fields]) + elif subel.tag == 'buildstats_file': + values['buildstats_file'] = subel.text + else: + raise TypeError("Unknown sysres value element '{}'".format(subel.tag)) + # DISKUSAGE measurement + elif elem.tag == 'diskusage': + values['size'] = int(elem.find('size').text) + else: + raise Exception("Unknown measurement tag '{}'".format(elem.tag)) + data['values'] = values + return data + + def _read_testcase(elem): + """Convert testcase into JSON""" + assert elem.tag == 'testcase', "Expecting 'testcase' element instead of {}".format(elem.tag) + + data = OrderedDict() + data['name'] = elem.attrib['name'] + data['description'] = elem.attrib['description'] + data['status'] = 'SUCCESS' + data['start_time'] = isofmt_to_timestamp(elem.attrib['timestamp']) + data['elapsed_time'] = float(elem.attrib['time']) + measurements = OrderedDict() + + for subel in elem.getchildren(): + if subel.tag == 'error' or subel.tag == 'failure': + data['status'] = subel.tag.upper() + data['message'] = subel.attrib['message'] + data['err_type'] = subel.attrib['type'] + data['err_output'] = subel.text + elif subel.tag == 'skipped': + data['status'] = 'SKIPPED' + data['message'] = subel.text + else: + measurements[subel.attrib['name']] = _read_measurement(subel) + data['measurements'] = measurements + return data + + def _read_testsuite(elem): + """Convert suite to JSON""" + assert elem.tag == 'testsuite', \ + "Expecting 'testsuite' element instead of {}".format(elem.tag) + + data = OrderedDict() + if 'hostname' in elem.attrib: + data['tester_host'] = elem.attrib['hostname'] + data['start_time'] = isofmt_to_timestamp(elem.attrib['timestamp']) + data['elapsed_time'] = float(elem.attrib['time']) + tests = OrderedDict() + + for case in elem.getchildren(): + tests[case.attrib['name']] = _read_testcase(case) + data['tests'] = tests + return data + + # Main function + assert elem.tag == 'testsuites', "Invalid test report format" + assert len(elem) == 1, "Too many testsuites" + + return _read_testsuite(elem.getchildren()[0]) + + +def aggregate_metadata(metadata): + """Aggregate metadata into one, basically a sanity check""" + mutable_keys = ('pretty_name', 'version_id') + + def aggregate_obj(aggregate, obj, assert_str=True): + """Aggregate objects together""" + assert type(aggregate) is type(obj), \ + "Type mismatch: {} != {}".format(type(aggregate), type(obj)) + if isinstance(obj, Mapping): + assert set(aggregate.keys()) == set(obj.keys()) + for key, val in obj.items(): + aggregate_obj(aggregate[key], val, key not in mutable_keys) + elif isinstance(obj, list): + assert len(aggregate) == len(obj) + for i, val in enumerate(obj): + aggregate_obj(aggregate[i], val) + elif not isinstance(obj, str) or (isinstance(obj, str) and assert_str): + assert aggregate == obj, "Data mismatch {} != {}".format(aggregate, obj) + + if not metadata: + return {} + + # Do the aggregation + aggregate = metadata[0].copy() + for testrun in metadata[1:]: + aggregate_obj(aggregate, testrun) + aggregate['testrun_count'] = len(metadata) + return aggregate + + +def aggregate_data(data): + """Aggregate multiple test results JSON structures into one""" + + mutable_keys = ('status', 'message', 'err_type', 'err_output') + + class SampleList(list): + """Container for numerical samples""" + pass + + def new_aggregate_obj(obj): + """Create new object for aggregate""" + if isinstance(obj, Number): + new_obj = SampleList() + new_obj.append(obj) + elif isinstance(obj, str): + new_obj = obj + else: + # Lists and and dicts are kept as is + new_obj = obj.__class__() + aggregate_obj(new_obj, obj) + return new_obj + + def aggregate_obj(aggregate, obj, assert_str=True): + """Recursive "aggregation" of JSON objects""" + if isinstance(obj, Number): + assert isinstance(aggregate, SampleList) + aggregate.append(obj) + return + + assert type(aggregate) == type(obj), \ + "Type mismatch: {} != {}".format(type(aggregate), type(obj)) + if isinstance(obj, Mapping): + for key, val in obj.items(): + if not key in aggregate: + aggregate[key] = new_aggregate_obj(val) + else: + aggregate_obj(aggregate[key], val, key not in mutable_keys) + elif isinstance(obj, list): + for i, val in enumerate(obj): + if i >= len(aggregate): + aggregate[key] = new_aggregate_obj(val) + else: + aggregate_obj(aggregate[i], val) + elif isinstance(obj, str): + # Sanity check for data + if assert_str: + assert aggregate == obj, "Data mismatch {} != {}".format(aggregate, obj) + else: + raise Exception("BUG: unable to aggregate '{}' ({})".format(type(obj), str(obj))) + + if not data: + return {} + + # Do the aggregation + aggregate = data[0].__class__() + for testrun in data: + aggregate_obj(aggregate, testrun) + return aggregate + + +class MeasurementVal(float): + """Base class representing measurement values""" + gv_data_type = 'number' + + def gv_value(self): + """Value formatting for visualization""" + if self != self: + return "null" + else: + return self + + +class TimeVal(MeasurementVal): + """Class representing time values""" + quantity = 'time' + gv_title = 'elapsed time' + gv_data_type = 'timeofday' + + def hms(self): + """Split time into hours, minutes and seconeds""" + hhh = int(abs(self) / 3600) + mmm = int((abs(self) % 3600) / 60) + sss = abs(self) % 60 + return hhh, mmm, sss + + def __str__(self): + if self != self: + return "nan" + hh, mm, ss = self.hms() + sign = '-' if self < 0 else '' + if hh > 0: + return '{}{:d}:{:02d}:{:02.0f}'.format(sign, hh, mm, ss) + elif mm > 0: + return '{}{:d}:{:04.1f}'.format(sign, mm, ss) + elif ss > 1: + return '{}{:.1f} s'.format(sign, ss) + else: + return '{}{:.2f} s'.format(sign, ss) + + def gv_value(self): + """Value formatting for visualization""" + if self != self: + return "null" + hh, mm, ss = self.hms() + return [hh, mm, int(ss), int(ss*1000) % 1000] + + +class SizeVal(MeasurementVal): + """Class representing time values""" + quantity = 'size' + gv_title = 'size in MiB' + gv_data_type = 'number' + + def __str__(self): + if self != self: + return "nan" + if abs(self) < 1024: + return '{:.1f} kiB'.format(self) + elif abs(self) < 1048576: + return '{:.2f} MiB'.format(self / 1024) + else: + return '{:.2f} GiB'.format(self / 1048576) + + def gv_value(self): + """Value formatting for visualization""" + if self != self: + return "null" + return self / 1024 + +def measurement_stats(meas, prefix=''): + """Get statistics of a measurement""" + if not meas: + return {prefix + 'sample_cnt': 0, + prefix + 'mean': MeasurementVal('nan'), + prefix + 'stdev': MeasurementVal('nan'), + prefix + 'variance': MeasurementVal('nan'), + prefix + 'min': MeasurementVal('nan'), + prefix + 'max': MeasurementVal('nan'), + prefix + 'minus': MeasurementVal('nan'), + prefix + 'plus': MeasurementVal('nan')} + + stats = {'name': meas['name']} + if meas['type'] == 'sysres': + val_cls = TimeVal + values = meas['values']['elapsed_time'] + elif meas['type'] == 'diskusage': + val_cls = SizeVal + values = meas['values']['size'] + else: + raise Exception("Unknown measurement type '{}'".format(meas['type'])) + stats['val_cls'] = val_cls + stats['quantity'] = val_cls.quantity + stats[prefix + 'sample_cnt'] = len(values) + + mean_val = val_cls(mean(values)) + min_val = val_cls(min(values)) + max_val = val_cls(max(values)) + + stats[prefix + 'mean'] = mean_val + if len(values) > 1: + stats[prefix + 'stdev'] = val_cls(stdev(values)) + stats[prefix + 'variance'] = val_cls(variance(values)) + else: + stats[prefix + 'stdev'] = float('nan') + stats[prefix + 'variance'] = float('nan') + stats[prefix + 'min'] = min_val + stats[prefix + 'max'] = max_val + stats[prefix + 'minus'] = val_cls(mean_val - min_val) + stats[prefix + 'plus'] = val_cls(max_val - mean_val) + + return stats + diff --git a/scripts/lib/build_perf/scrape-html-report.js b/scripts/lib/build_perf/scrape-html-report.js new file mode 100644 index 0000000000..05a1f57001 --- /dev/null +++ b/scripts/lib/build_perf/scrape-html-report.js @@ -0,0 +1,56 @@ +var fs = require('fs'); +var system = require('system'); +var page = require('webpage').create(); + +// Examine console log for message from chart drawing +page.onConsoleMessage = function(msg) { + console.log(msg); + if (msg === "ALL CHARTS READY") { + window.charts_ready = true; + } + else if (msg.slice(0, 11) === "CHART READY") { + var chart_id = msg.split(" ")[2]; + console.log('grabbing ' + chart_id); + var png_data = page.evaluate(function (chart_id) { + var chart_div = document.getElementById(chart_id + '_png'); + return chart_div.outerHTML; + }, chart_id); + fs.write(args[2] + '/' + chart_id + '.png', png_data, 'w'); + } +}; + +// Check command line arguments +var args = system.args; +if (args.length != 3) { + console.log("USAGE: " + args[0] + " REPORT_HTML OUT_DIR\n"); + phantom.exit(1); +} + +// Open the web page +page.open(args[1], function(status) { + if (status == 'fail') { + console.log("Failed to open file '" + args[1] + "'"); + phantom.exit(1); + } +}); + +// Check status every 100 ms +interval = window.setInterval(function () { + //console.log('waiting'); + if (window.charts_ready) { + clearTimeout(timer); + clearInterval(interval); + + var fname = args[1].replace(/\/+$/, "").split("/").pop() + console.log("saving " + fname); + fs.write(args[2] + '/' + fname, page.content, 'w'); + phantom.exit(0); + } +}, 100); + +// Time-out after 10 seconds +timer = window.setTimeout(function () { + clearInterval(interval); + console.log("ERROR: timeout"); + phantom.exit(1); +}, 10000); diff --git a/scripts/lib/compatlayer/__init__.py b/scripts/lib/compatlayer/__init__.py new file mode 100644 index 0000000000..e35f8c0d32 --- /dev/null +++ b/scripts/lib/compatlayer/__init__.py @@ -0,0 +1,308 @@ +# Yocto Project compatibility layer tool +# +# Copyright (C) 2017 Intel Corporation +# Released under the MIT license (see COPYING.MIT) + +import os +import subprocess +from enum import Enum + +import bb.tinfoil + +class LayerType(Enum): + BSP = 0 + DISTRO = 1 + SOFTWARE = 2 + ERROR_NO_LAYER_CONF = 98 + ERROR_BSP_DISTRO = 99 + +def _get_configurations(path): + configs = [] + + for f in os.listdir(path): + file_path = os.path.join(path, f) + if os.path.isfile(file_path) and f.endswith('.conf'): + configs.append(f[:-5]) # strip .conf + return configs + +def _get_layer_collections(layer_path, lconf=None, data=None): + import bb.parse + import bb.data + + if lconf is None: + lconf = os.path.join(layer_path, 'conf', 'layer.conf') + + if data is None: + ldata = bb.data.init() + bb.parse.init_parser(ldata) + else: + ldata = data.createCopy() + + ldata.setVar('LAYERDIR', layer_path) + try: + ldata = bb.parse.handle(lconf, ldata, include=True) + except BaseException as exc: + raise LayerError(exc) + ldata.expandVarref('LAYERDIR') + + collections = (ldata.getVar('BBFILE_COLLECTIONS', True) or '').split() + if not collections: + name = os.path.basename(layer_path) + collections = [name] + + collections = {c: {} for c in collections} + for name in collections: + priority = ldata.getVar('BBFILE_PRIORITY_%s' % name, True) + pattern = ldata.getVar('BBFILE_PATTERN_%s' % name, True) + depends = ldata.getVar('LAYERDEPENDS_%s' % name, True) + collections[name]['priority'] = priority + collections[name]['pattern'] = pattern + collections[name]['depends'] = depends + + return collections + +def _detect_layer(layer_path): + """ + Scans layer directory to detect what type of layer + is BSP, Distro or Software. + + Returns a dictionary with layer name, type and path. + """ + + layer = {} + layer_name = os.path.basename(layer_path) + + layer['name'] = layer_name + layer['path'] = layer_path + layer['conf'] = {} + + if not os.path.isfile(os.path.join(layer_path, 'conf', 'layer.conf')): + layer['type'] = LayerType.ERROR_NO_LAYER_CONF + return layer + + machine_conf = os.path.join(layer_path, 'conf', 'machine') + distro_conf = os.path.join(layer_path, 'conf', 'distro') + + is_bsp = False + is_distro = False + + if os.path.isdir(machine_conf): + machines = _get_configurations(machine_conf) + if machines: + is_bsp = True + + if os.path.isdir(distro_conf): + distros = _get_configurations(distro_conf) + if distros: + is_distro = True + + if is_bsp and is_distro: + layer['type'] = LayerType.ERROR_BSP_DISTRO + elif is_bsp: + layer['type'] = LayerType.BSP + layer['conf']['machines'] = machines + elif is_distro: + layer['type'] = LayerType.DISTRO + layer['conf']['distros'] = distros + else: + layer['type'] = LayerType.SOFTWARE + + layer['collections'] = _get_layer_collections(layer['path']) + + return layer + +def detect_layers(layer_directories, no_auto): + layers = [] + + for directory in layer_directories: + directory = os.path.realpath(directory) + if directory[-1] == '/': + directory = directory[0:-1] + + if no_auto: + conf_dir = os.path.join(directory, 'conf') + if os.path.isdir(conf_dir): + layer = _detect_layer(directory) + if layer: + layers.append(layer) + else: + for root, dirs, files in os.walk(directory): + dir_name = os.path.basename(root) + conf_dir = os.path.join(root, 'conf') + if os.path.isdir(conf_dir): + layer = _detect_layer(root) + if layer: + layers.append(layer) + + return layers + +def _find_layer_depends(depend, layers): + for layer in layers: + for collection in layer['collections']: + if depend == collection: + return layer + return None + +def add_layer_dependencies(bblayersconf, layer, layers, logger): + def recurse_dependencies(depends, layer, layers, logger, ret = []): + logger.debug('Processing dependencies %s for layer %s.' % \ + (depends, layer['name'])) + + for depend in depends.split(): + # core (oe-core) is suppose to be provided + if depend == 'core': + continue + + layer_depend = _find_layer_depends(depend, layers) + if not layer_depend: + logger.error('Layer %s depends on %s and isn\'t found.' % \ + (layer['name'], depend)) + ret = None + continue + + # We keep processing, even if ret is None, this allows us to report + # multiple errors at once + if ret is not None and layer_depend not in ret: + ret.append(layer_depend) + + # Recursively process... + if 'collections' not in layer_depend: + continue + + for collection in layer_depend['collections']: + collect_deps = layer_depend['collections'][collection]['depends'] + if not collect_deps: + continue + ret = recurse_dependencies(collect_deps, layer_depend, layers, logger, ret) + + return ret + + layer_depends = [] + for collection in layer['collections']: + depends = layer['collections'][collection]['depends'] + if not depends: + continue + + layer_depends = recurse_dependencies(depends, layer, layers, logger, layer_depends) + + # Note: [] (empty) is allowed, None is not! + if layer_depends is None: + return False + else: + for layer_depend in layer_depends: + logger.info('Adding layer dependency %s' % layer_depend['name']) + with open(bblayersconf, 'a+') as f: + f.write("\nBBLAYERS += \"%s\"\n" % layer_depend['path']) + return True + +def add_layer(bblayersconf, layer, layers, logger): + logger.info('Adding layer %s' % layer['name']) + with open(bblayersconf, 'a+') as f: + f.write("\nBBLAYERS += \"%s\"\n" % layer['path']) + + return True + +def check_command(error_msg, cmd): + ''' + Run a command under a shell, capture stdout and stderr in a single stream, + throw an error when command returns non-zero exit code. Returns the output. + ''' + + p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) + output, _ = p.communicate() + if p.returncode: + msg = "%s\nCommand: %s\nOutput:\n%s" % (error_msg, cmd, output.decode('utf-8')) + raise RuntimeError(msg) + return output + +def get_signatures(builddir, failsafe=False, machine=None): + import re + + # some recipes needs to be excluded like meta-world-pkgdata + # because a layer can add recipes to a world build so signature + # will be change + exclude_recipes = ('meta-world-pkgdata',) + + sigs = {} + tune2tasks = {} + + cmd = '' + if machine: + cmd += 'MACHINE=%s ' % machine + cmd += 'bitbake ' + if failsafe: + cmd += '-k ' + cmd += '-S none world' + sigs_file = os.path.join(builddir, 'locked-sigs.inc') + if os.path.exists(sigs_file): + os.unlink(sigs_file) + try: + check_command('Generating signatures failed. This might be due to some parse error and/or general layer incompatibilities.', + cmd) + except RuntimeError as ex: + if failsafe and os.path.exists(sigs_file): + # Ignore the error here. Most likely some recipes active + # in a world build lack some dependencies. There is a + # separate test_machine_world_build which exposes the + # failure. + pass + else: + raise + + sig_regex = re.compile("^(?P<task>.*:.*):(?P<hash>.*) .$") + tune_regex = re.compile("(^|\s)SIGGEN_LOCKEDSIGS_t-(?P<tune>\S*)\s*=\s*") + current_tune = None + with open(sigs_file, 'r') as f: + for line in f.readlines(): + line = line.strip() + t = tune_regex.search(line) + if t: + current_tune = t.group('tune') + s = sig_regex.match(line) + if s: + exclude = False + for er in exclude_recipes: + (recipe, task) = s.group('task').split(':') + if er == recipe: + exclude = True + break + if exclude: + continue + + sigs[s.group('task')] = s.group('hash') + tune2tasks.setdefault(current_tune, []).append(s.group('task')) + + if not sigs: + raise RuntimeError('Can\'t load signatures from %s' % sigs_file) + + return (sigs, tune2tasks) + +def get_depgraph(targets=['world']): + ''' + Returns the dependency graph for the given target(s). + The dependency graph is taken directly from DepTreeEvent. + ''' + depgraph = None + with bb.tinfoil.Tinfoil() as tinfoil: + tinfoil.prepare(config_only=False) + tinfoil.set_event_mask(['bb.event.NoProvider', 'bb.event.DepTreeGenerated', 'bb.command.CommandCompleted']) + if not tinfoil.run_command('generateDepTreeEvent', targets, 'do_build'): + raise RuntimeError('starting generateDepTreeEvent failed') + while True: + event = tinfoil.wait_event(timeout=1000) + if event: + if isinstance(event, bb.command.CommandFailed): + raise RuntimeError('Generating dependency information failed: %s' % event.error) + elif isinstance(event, bb.command.CommandCompleted): + break + elif isinstance(event, bb.event.NoProvider): + if event._reasons: + raise RuntimeError('Nothing provides %s: %s' % (event._item, event._reasons)) + else: + raise RuntimeError('Nothing provides %s.' % (event._item)) + elif isinstance(event, bb.event.DepTreeGenerated): + depgraph = event._depgraph + + if depgraph is None: + raise RuntimeError('Could not retrieve the depgraph.') + return depgraph diff --git a/scripts/lib/compatlayer/case.py b/scripts/lib/compatlayer/case.py new file mode 100644 index 0000000000..54ce78aa60 --- /dev/null +++ b/scripts/lib/compatlayer/case.py @@ -0,0 +1,7 @@ +# Copyright (C) 2017 Intel Corporation +# Released under the MIT license (see COPYING.MIT) + +from oeqa.core.case import OETestCase + +class OECompatLayerTestCase(OETestCase): + pass diff --git a/scripts/lib/mic/3rdparty/pykickstart/__init__.py b/scripts/lib/compatlayer/cases/__init__.py index e69de29bb2..e69de29bb2 100644 --- a/scripts/lib/mic/3rdparty/pykickstart/__init__.py +++ b/scripts/lib/compatlayer/cases/__init__.py diff --git a/scripts/lib/compatlayer/cases/bsp.py b/scripts/lib/compatlayer/cases/bsp.py new file mode 100644 index 0000000000..43efae406f --- /dev/null +++ b/scripts/lib/compatlayer/cases/bsp.py @@ -0,0 +1,204 @@ +# Copyright (C) 2017 Intel Corporation +# Released under the MIT license (see COPYING.MIT) + +import unittest + +from compatlayer import LayerType, get_signatures, check_command, get_depgraph +from compatlayer.case import OECompatLayerTestCase + +class BSPCompatLayer(OECompatLayerTestCase): + @classmethod + def setUpClass(self): + if self.tc.layer['type'] != LayerType.BSP: + raise unittest.SkipTest("BSPCompatLayer: Layer %s isn't BSP one." %\ + self.tc.layer['name']) + + def test_bsp_defines_machines(self): + self.assertTrue(self.tc.layer['conf']['machines'], + "Layer is BSP but doesn't defines machines.") + + def test_bsp_no_set_machine(self): + from oeqa.utils.commands import get_bb_var + + machine = get_bb_var('MACHINE') + self.assertEqual(self.td['bbvars']['MACHINE'], machine, + msg="Layer %s modified machine %s -> %s" % \ + (self.tc.layer['name'], self.td['bbvars']['MACHINE'], machine)) + + + def test_machine_world(self): + ''' + "bitbake world" is expected to work regardless which machine is selected. + BSP layers sometimes break that by enabling a recipe for a certain machine + without checking whether that recipe actually can be built in the current + distro configuration (for example, OpenGL might not enabled). + + This test iterates over all machines. It would be nicer to instantiate + it once per machine. It merely checks for errors during parse + time. It does not actually attempt to build anything. + ''' + + if not self.td['machines']: + self.skipTest('No machines set with --machines.') + msg = [] + for machine in self.td['machines']: + # In contrast to test_machine_signatures() below, errors are fatal here. + try: + get_signatures(self.td['builddir'], failsafe=False, machine=machine) + except RuntimeError as ex: + msg.append(str(ex)) + if msg: + msg.insert(0, 'The following machines broke a world build:') + self.fail('\n'.join(msg)) + + def test_machine_signatures(self): + ''' + Selecting a machine may only affect the signature of tasks that are specific + to that machine. In other words, when MACHINE=A and MACHINE=B share a recipe + foo and the output of foo, then both machine configurations must build foo + in exactly the same way. Otherwise it is not possible to use both machines + in the same distribution. + + This criteria can only be tested by testing different machines in combination, + i.e. one main layer, potentially several additional BSP layers and an explicit + choice of machines: + yocto-compat-layer --additional-layers .../meta-intel --machines intel-corei7-64 imx6slevk -- .../meta-freescale + ''' + + if not self.td['machines']: + self.skipTest('No machines set with --machines.') + + # Collect signatures for all machines that we are testing + # and merge that into a hash: + # tune -> task -> signature -> list of machines with that combination + # + # It is an error if any tune/task pair has more than one signature, + # because that implies that the machines that caused those different + # signatures do not agree on how to execute the task. + tunes = {} + # Preserve ordering of machines as chosen by the user. + for machine in self.td['machines']: + curr_sigs, tune2tasks = get_signatures(self.td['builddir'], failsafe=True, machine=machine) + # Invert the tune -> [tasks] mapping. + tasks2tune = {} + for tune, tasks in tune2tasks.items(): + for task in tasks: + tasks2tune[task] = tune + for task, sighash in curr_sigs.items(): + tunes.setdefault(tasks2tune[task], {}).setdefault(task, {}).setdefault(sighash, []).append(machine) + + msg = [] + pruned = 0 + last_line_key = None + # do_fetch, do_unpack, ..., do_build + taskname_list = [] + if tunes: + # The output below is most useful when we start with tasks that are at + # the bottom of the dependency chain, i.e. those that run first. If + # those tasks differ, the rest also does. + # + # To get an ordering of tasks, we do a topological sort of the entire + # depgraph for the base configuration, then on-the-fly flatten that list by stripping + # out the recipe names and removing duplicates. The base configuration + # is not necessarily representative, but should be close enough. Tasks + # that were not encountered get a default priority. + depgraph = get_depgraph() + depends = depgraph['tdepends'] + WHITE = 1 + GRAY = 2 + BLACK = 3 + color = {} + found = set() + def visit(task): + color[task] = GRAY + for dep in depends.get(task, ()): + if color.setdefault(dep, WHITE) == WHITE: + visit(dep) + color[task] = BLACK + pn, taskname = task.rsplit('.', 1) + if taskname not in found: + taskname_list.append(taskname) + found.add(taskname) + for task in depends.keys(): + if color.setdefault(task, WHITE) == WHITE: + visit(task) + + taskname_order = dict([(task, index) for index, task in enumerate(taskname_list) ]) + def task_key(task): + pn, taskname = task.rsplit(':', 1) + return (pn, taskname_order.get(taskname, len(taskname_list)), taskname) + + for tune in sorted(tunes.keys()): + tasks = tunes[tune] + # As for test_signatures it would be nicer to sort tasks + # by dependencies here, but that is harder because we have + # to report on tasks from different machines, which might + # have different dependencies. We resort to pruning the + # output by reporting only one task per recipe if the set + # of machines matches. + # + # "bitbake-diffsigs -t -s" is intelligent enough to print + # diffs recursively, so often it does not matter that much + # if we don't pick the underlying difference + # here. However, sometimes recursion fails + # (https://bugzilla.yoctoproject.org/show_bug.cgi?id=6428). + # + # To mitigate that a bit, we use a hard-coded ordering of + # tasks that represents how they normally run and prefer + # to print the ones that run first. + for task in sorted(tasks.keys(), key=task_key): + signatures = tasks[task] + # do_build can be ignored: it is know to have + # different signatures in some cases, for example in + # the allarch ca-certificates due to RDEPENDS=openssl. + # That particular dependency is whitelisted via + # SIGGEN_EXCLUDE_SAFE_RECIPE_DEPS, but still shows up + # in the sstate signature hash because filtering it + # out would be hard and running do_build multiple + # times doesn't really matter. + if len(signatures.keys()) > 1 and \ + not task.endswith(':do_build'): + # Error! + # + # Sort signatures by machines, because the hex values don't mean anything. + # => all-arch adwaita-icon-theme:do_build: 1234... (beaglebone, qemux86) != abcdf... (qemux86-64) + # + # Skip the line if it is covered already by the predecessor (same pn, same sets of machines). + pn, taskname = task.rsplit(':', 1) + next_line_key = (pn, sorted(signatures.values())) + if next_line_key != last_line_key: + line = ' %s %s: ' % (tune, task) + line += ' != '.join(['%s (%s)' % (signature, ', '.join([m for m in signatures[signature]])) for + signature in sorted(signatures.keys(), key=lambda s: signatures[s])]) + last_line_key = next_line_key + msg.append(line) + # Randomly pick two mismatched signatures and remember how to invoke + # bitbake-diffsigs for them. + iterator = iter(signatures.items()) + a = next(iterator) + b = next(iterator) + diffsig_machines = '(%s) != (%s)' % (', '.join(a[1]), ', '.join(b[1])) + diffsig_params = '-t %s %s -s %s %s' % (pn, taskname, a[0], b[0]) + else: + pruned += 1 + + if msg: + msg.insert(0, 'The machines have conflicting signatures for some shared tasks:') + if pruned > 0: + msg.append('') + msg.append('%d tasks where not listed because some other task of the recipe already differed.' % pruned) + msg.append('It is likely that differences from different recipes also have the same root cause.') + msg.append('') + # Explain how to investigate... + msg.append('To investigate, run bitbake-diffsigs -t recipename taskname -s fromsig tosig.') + cmd = 'bitbake-diffsigs %s' % diffsig_params + msg.append('Example: %s in the last line' % diffsig_machines) + msg.append('Command: %s' % cmd) + # ... and actually do it automatically for that example, but without aborting + # when that fails. + try: + output = check_command('Comparing signatures failed.', cmd).decode('utf-8') + except RuntimeError as ex: + output = str(ex) + msg.extend([' ' + line for line in output.splitlines()]) + self.fail('\n'.join(msg)) diff --git a/scripts/lib/compatlayer/cases/common.py b/scripts/lib/compatlayer/cases/common.py new file mode 100644 index 0000000000..8eeada9b1e --- /dev/null +++ b/scripts/lib/compatlayer/cases/common.py @@ -0,0 +1,91 @@ +# Copyright (C) 2017 Intel Corporation +# Released under the MIT license (see COPYING.MIT) + +import os +import unittest +from compatlayer import get_signatures, LayerType, check_command, get_depgraph +from compatlayer.case import OECompatLayerTestCase + +class CommonCompatLayer(OECompatLayerTestCase): + def test_readme(self): + readme_file = os.path.join(self.tc.layer['path'], 'README') + self.assertTrue(os.path.isfile(readme_file), + msg="Layer doesn't contains README file.") + + data = '' + with open(readme_file, 'r') as f: + data = f.read() + self.assertTrue(data, + msg="Layer contains README file but is empty.") + + def test_parse(self): + check_command('Layer %s failed to parse.' % self.tc.layer['name'], + 'bitbake -p') + + def test_show_environment(self): + check_command('Layer %s failed to show environment.' % self.tc.layer['name'], + 'bitbake -e') + + def test_signatures(self): + if self.tc.layer['type'] == LayerType.SOFTWARE: + raise unittest.SkipTest("Layer %s isn't BSP or DISTRO one." \ + % self.tc.layer['name']) + + # task -> (old signature, new signature) + sig_diff = {} + curr_sigs, _ = get_signatures(self.td['builddir'], failsafe=True) + for task in self.td['sigs']: + if task in curr_sigs and \ + self.td['sigs'][task] != curr_sigs[task]: + sig_diff[task] = (self.td['sigs'][task], curr_sigs[task]) + + if sig_diff: + # Beware, depgraph uses task=<pn>.<taskname> whereas get_signatures() + # uses <pn>:<taskname>. Need to convert sometimes. The output follows + # the convention from get_signatures() because that seems closer to + # normal bitbake output. + def sig2graph(task): + pn, taskname = task.rsplit(':', 1) + return pn + '.' + taskname + def graph2sig(task): + pn, taskname = task.rsplit('.', 1) + return pn + ':' + taskname + depgraph = get_depgraph() + depends = depgraph['tdepends'] + + # If a task A has a changed signature, but none of its + # dependencies, then we need to report it because it is + # the one which introduces a change. Any task depending on + # A (directly or indirectly) will also have a changed + # signature, but we don't need to report it. It might have + # its own changes, which will become apparent once the + # issues that we do report are fixed and the test gets run + # again. + sig_diff_filtered = [] + for task, (old_sig, new_sig) in sig_diff.items(): + deps_tainted = False + for dep in depends.get(sig2graph(task), ()): + if graph2sig(dep) in sig_diff: + deps_tainted = True + break + if not deps_tainted: + sig_diff_filtered.append((task, old_sig, new_sig)) + + msg = [] + msg.append('Layer %s changed %d signatures, initial differences (first hash without, second with layer):' % + (self.tc.layer['name'], len(sig_diff))) + for diff in sorted(sig_diff_filtered): + recipe, taskname = diff[0].rsplit(':', 1) + cmd = 'bitbake-diffsigs --task %s %s --signature %s %s' % \ + (recipe, taskname, diff[1], diff[2]) + msg.append(' %s: %s -> %s' % diff) + msg.append(' %s' % cmd) + try: + output = check_command('Determining signature difference failed.', + cmd).decode('utf-8') + except RuntimeError as error: + output = str(error) + if output: + msg.extend([' ' + line for line in output.splitlines()]) + msg.append('') + self.fail('\n'.join(msg)) diff --git a/scripts/lib/compatlayer/cases/distro.py b/scripts/lib/compatlayer/cases/distro.py new file mode 100644 index 0000000000..523acc1e78 --- /dev/null +++ b/scripts/lib/compatlayer/cases/distro.py @@ -0,0 +1,26 @@ +# Copyright (C) 2017 Intel Corporation +# Released under the MIT license (see COPYING.MIT) + +import unittest + +from compatlayer import LayerType +from compatlayer.case import OECompatLayerTestCase + +class DistroCompatLayer(OECompatLayerTestCase): + @classmethod + def setUpClass(self): + if self.tc.layer['type'] != LayerType.DISTRO: + raise unittest.SkipTest("DistroCompatLayer: Layer %s isn't Distro one." %\ + self.tc.layer['name']) + + def test_distro_defines_distros(self): + self.assertTrue(self.tc.layer['conf']['distros'], + "Layer is BSP but doesn't defines machines.") + + def test_distro_no_set_distros(self): + from oeqa.utils.commands import get_bb_var + + distro = get_bb_var('DISTRO') + self.assertEqual(self.td['bbvars']['DISTRO'], distro, + msg="Layer %s modified distro %s -> %s" % \ + (self.tc.layer['name'], self.td['bbvars']['DISTRO'], distro)) diff --git a/scripts/lib/compatlayer/context.py b/scripts/lib/compatlayer/context.py new file mode 100644 index 0000000000..4932238798 --- /dev/null +++ b/scripts/lib/compatlayer/context.py @@ -0,0 +1,14 @@ +# Copyright (C) 2017 Intel Corporation +# Released under the MIT license (see COPYING.MIT) + +import os +import sys +import glob +import re + +from oeqa.core.context import OETestContext + +class CompatLayerTestContext(OETestContext): + def __init__(self, td=None, logger=None, layer=None): + super(CompatLayerTestContext, self).__init__(td, logger) + self.layer = layer diff --git a/scripts/lib/devtool/__init__.py b/scripts/lib/devtool/__init__.py new file mode 100644 index 0000000000..d646b0cf63 --- /dev/null +++ b/scripts/lib/devtool/__init__.py @@ -0,0 +1,294 @@ +#!/usr/bin/env python3 + +# Development tool - utility functions for plugins +# +# Copyright (C) 2014 Intel Corporation +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +"""Devtool plugins module""" + +import os +import sys +import subprocess +import logging +import re +import codecs + +logger = logging.getLogger('devtool') + +class DevtoolError(Exception): + """Exception for handling devtool errors""" + def __init__(self, message, exitcode=1): + super(DevtoolError, self).__init__(message) + self.exitcode = exitcode + + +def exec_build_env_command(init_path, builddir, cmd, watch=False, **options): + """Run a program in bitbake build context""" + import bb + if not 'cwd' in options: + options["cwd"] = builddir + if init_path: + # As the OE init script makes use of BASH_SOURCE to determine OEROOT, + # and can't determine it when running under dash, we need to set + # the executable to bash to correctly set things up + if not 'executable' in options: + options['executable'] = 'bash' + logger.debug('Executing command: "%s" using init path %s' % (cmd, init_path)) + init_prefix = '. %s %s > /dev/null && ' % (init_path, builddir) + else: + logger.debug('Executing command "%s"' % cmd) + init_prefix = '' + if watch: + if sys.stdout.isatty(): + # Fool bitbake into thinking it's outputting to a terminal (because it is, indirectly) + cmd = 'script -e -q -c "%s" /dev/null' % cmd + return exec_watch('%s%s' % (init_prefix, cmd), **options) + else: + return bb.process.run('%s%s' % (init_prefix, cmd), **options) + +def exec_watch(cmd, **options): + """Run program with stdout shown on sys.stdout""" + import bb + if isinstance(cmd, str) and not "shell" in options: + options["shell"] = True + + process = subprocess.Popen( + cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, **options + ) + + reader = codecs.getreader('utf-8')(process.stdout) + buf = '' + while True: + out = reader.read(1, 1) + if out: + sys.stdout.write(out) + sys.stdout.flush() + buf += out + elif out == '' and process.poll() != None: + break + + if process.returncode != 0: + raise bb.process.ExecutionError(cmd, process.returncode, buf, None) + + return buf, None + +def exec_fakeroot(d, cmd, **kwargs): + """Run a command under fakeroot (pseudo, in fact) so that it picks up the appropriate file permissions""" + # Grab the command and check it actually exists + fakerootcmd = d.getVar('FAKEROOTCMD') + if not os.path.exists(fakerootcmd): + logger.error('pseudo executable %s could not be found - have you run a build yet? pseudo-native should install this and if you have run any build then that should have been built') + return 2 + # Set up the appropriate environment + newenv = dict(os.environ) + fakerootenv = d.getVar('FAKEROOTENV') + for varvalue in fakerootenv.split(): + if '=' in varvalue: + splitval = varvalue.split('=', 1) + newenv[splitval[0]] = splitval[1] + return subprocess.call("%s %s" % (fakerootcmd, cmd), env=newenv, **kwargs) + +def setup_tinfoil(config_only=False, basepath=None, tracking=False): + """Initialize tinfoil api from bitbake""" + import scriptpath + orig_cwd = os.path.abspath(os.curdir) + try: + if basepath: + os.chdir(basepath) + bitbakepath = scriptpath.add_bitbake_lib_path() + if not bitbakepath: + logger.error("Unable to find bitbake by searching parent directory of this script or PATH") + sys.exit(1) + + import bb.tinfoil + tinfoil = bb.tinfoil.Tinfoil(tracking=tracking) + try: + tinfoil.prepare(config_only) + tinfoil.logger.setLevel(logger.getEffectiveLevel()) + except bb.tinfoil.TinfoilUIException: + tinfoil.shutdown() + raise DevtoolError('Failed to start bitbake environment') + except: + tinfoil.shutdown() + raise + finally: + os.chdir(orig_cwd) + return tinfoil + +def parse_recipe(config, tinfoil, pn, appends, filter_workspace=True): + """Parse the specified recipe""" + try: + recipefile = tinfoil.get_recipe_file(pn) + except bb.providers.NoProvider as e: + logger.error(str(e)) + return None + if appends: + append_files = tinfoil.get_file_appends(recipefile) + if filter_workspace: + # Filter out appends from the workspace + append_files = [path for path in append_files if + not path.startswith(config.workspace_path)] + else: + append_files = None + try: + rd = tinfoil.parse_recipe_file(recipefile, appends, append_files) + except Exception as e: + logger.error(str(e)) + return None + return rd + +def check_workspace_recipe(workspace, pn, checksrc=True, bbclassextend=False): + """ + Check that a recipe is in the workspace and (optionally) that source + is present. + """ + + workspacepn = pn + + for recipe, value in workspace.items(): + if recipe == pn: + break + if bbclassextend: + recipefile = value['recipefile'] + if recipefile: + targets = get_bbclassextend_targets(recipefile, recipe) + if pn in targets: + workspacepn = recipe + break + else: + raise DevtoolError("No recipe named '%s' in your workspace" % pn) + + if checksrc: + srctree = workspace[workspacepn]['srctree'] + if not os.path.exists(srctree): + raise DevtoolError("Source tree %s for recipe %s does not exist" % (srctree, workspacepn)) + if not os.listdir(srctree): + raise DevtoolError("Source tree %s for recipe %s is empty" % (srctree, workspacepn)) + + return workspacepn + +def use_external_build(same_dir, no_same_dir, d): + """ + Determine if we should use B!=S (separate build and source directories) or not + """ + b_is_s = True + if no_same_dir: + logger.info('Using separate build directory since --no-same-dir specified') + b_is_s = False + elif same_dir: + logger.info('Using source tree as build directory since --same-dir specified') + elif bb.data.inherits_class('autotools-brokensep', d): + logger.info('Using source tree as build directory since recipe inherits autotools-brokensep') + elif d.getVar('B') == os.path.abspath(d.getVar('S')): + logger.info('Using source tree as build directory since that would be the default for this recipe') + else: + b_is_s = False + return b_is_s + +def setup_git_repo(repodir, version, devbranch, basetag='devtool-base', d=None): + """ + Set up the git repository for the source tree + """ + import bb.process + import oe.patch + if not os.path.exists(os.path.join(repodir, '.git')): + bb.process.run('git init', cwd=repodir) + bb.process.run('git add .', cwd=repodir) + commit_cmd = ['git'] + oe.patch.GitApplyTree.gitCommandUserOptions(commit_cmd, d=d) + commit_cmd += ['commit', '-q'] + stdout, _ = bb.process.run('git status --porcelain', cwd=repodir) + if not stdout: + commit_cmd.append('--allow-empty') + commitmsg = "Initial empty commit with no upstream sources" + elif version: + commitmsg = "Initial commit from upstream at version %s" % version + else: + commitmsg = "Initial commit from upstream" + commit_cmd += ['-m', commitmsg] + bb.process.run(commit_cmd, cwd=repodir) + + bb.process.run('git checkout -b %s' % devbranch, cwd=repodir) + bb.process.run('git tag -f %s' % basetag, cwd=repodir) + +def recipe_to_append(recipefile, config, wildcard=False): + """ + Convert a recipe file to a bbappend file path within the workspace. + NOTE: if the bbappend already exists, you should be using + workspace[args.recipename]['bbappend'] instead of calling this + function. + """ + appendname = os.path.splitext(os.path.basename(recipefile))[0] + if wildcard: + appendname = re.sub(r'_.*', '_%', appendname) + appendpath = os.path.join(config.workspace_path, 'appends') + appendfile = os.path.join(appendpath, appendname + '.bbappend') + return appendfile + +def get_bbclassextend_targets(recipefile, pn): + """ + Cheap function to get BBCLASSEXTEND and then convert that to the + list of targets that would result. + """ + import bb.utils + + values = {} + def get_bbclassextend_varfunc(varname, origvalue, op, newlines): + values[varname] = origvalue + return origvalue, None, 0, True + with open(recipefile, 'r') as f: + bb.utils.edit_metadata(f, ['BBCLASSEXTEND'], get_bbclassextend_varfunc) + + targets = [] + bbclassextend = values.get('BBCLASSEXTEND', '').split() + if bbclassextend: + for variant in bbclassextend: + if variant == 'nativesdk': + targets.append('%s-%s' % (variant, pn)) + elif variant in ['native', 'cross', 'crosssdk']: + targets.append('%s-%s' % (pn, variant)) + return targets + +def ensure_npm(config, basepath, fixed_setup=False, check_exists=True): + """ + Ensure that npm is available and either build it or show a + reasonable error message + """ + if check_exists: + tinfoil = setup_tinfoil(config_only=False, basepath=basepath) + try: + rd = tinfoil.parse_recipe('nodejs-native') + nativepath = rd.getVar('STAGING_BINDIR_NATIVE') + finally: + tinfoil.shutdown() + npmpath = os.path.join(nativepath, 'npm') + build_npm = not os.path.exists(npmpath) + else: + build_npm = True + + if build_npm: + logger.info('Building nodejs-native') + try: + exec_build_env_command(config.init_path, basepath, + 'bitbake -q nodejs-native -c addto_recipe_sysroot', watch=True) + except bb.process.ExecutionError as e: + if "Nothing PROVIDES 'nodejs-native'" in e.stdout: + if fixed_setup: + msg = 'nodejs-native is required for npm but is not available within this SDK' + else: + msg = 'nodejs-native is required for npm but is not available - you will likely need to add a layer that provides nodejs' + raise DevtoolError(msg) + else: + raise diff --git a/scripts/lib/devtool/build.py b/scripts/lib/devtool/build.py new file mode 100644 index 0000000000..252379e9b2 --- /dev/null +++ b/scripts/lib/devtool/build.py @@ -0,0 +1,86 @@ +# Development tool - build command plugin +# +# Copyright (C) 2014-2015 Intel Corporation +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +"""Devtool build plugin""" + +import os +import bb +import logging +import argparse +import tempfile +from devtool import exec_build_env_command, check_workspace_recipe, DevtoolError + +logger = logging.getLogger('devtool') + + +def _set_file_values(fn, values): + remaining = list(values.keys()) + + def varfunc(varname, origvalue, op, newlines): + newvalue = values.get(varname, origvalue) + remaining.remove(varname) + return (newvalue, '=', 0, True) + + with open(fn, 'r') as f: + (updated, newlines) = bb.utils.edit_metadata(f, values, varfunc) + + for item in remaining: + updated = True + newlines.append('%s = "%s"' % (item, values[item])) + + if updated: + with open(fn, 'w') as f: + f.writelines(newlines) + return updated + +def _get_build_tasks(config): + tasks = config.get('Build', 'build_task', 'populate_sysroot,packagedata').split(',') + return ['do_%s' % task.strip() for task in tasks] + +def build(args, config, basepath, workspace): + """Entry point for the devtool 'build' subcommand""" + workspacepn = check_workspace_recipe(workspace, args.recipename, bbclassextend=True) + + build_tasks = _get_build_tasks(config) + + bbappend = workspace[workspacepn]['bbappend'] + if args.disable_parallel_make: + logger.info("Disabling 'make' parallelism") + _set_file_values(bbappend, {'PARALLEL_MAKE': ''}) + try: + bbargs = [] + for task in build_tasks: + if args.recipename.endswith('-native') and 'package' in task: + continue + bbargs.append('%s:%s' % (args.recipename, task)) + exec_build_env_command(config.init_path, basepath, 'bitbake %s' % ' '.join(bbargs), watch=True) + except bb.process.ExecutionError as e: + # We've already seen the output since watch=True, so just ensure we return something to the user + return e.exitcode + finally: + if args.disable_parallel_make: + _set_file_values(bbappend, {'PARALLEL_MAKE': None}) + + return 0 + +def register_commands(subparsers, context): + """Register devtool subcommands from this plugin""" + parser_build = subparsers.add_parser('build', help='Build a recipe', + description='Builds the specified recipe using bitbake (up to and including %s)' % ', '.join(_get_build_tasks(context.config)), + group='working', order=50) + parser_build.add_argument('recipename', help='Recipe to build') + parser_build.add_argument('-s', '--disable-parallel-make', action="store_true", help='Disable make parallelism') + parser_build.set_defaults(func=build) diff --git a/scripts/lib/devtool/build_image.py b/scripts/lib/devtool/build_image.py new file mode 100644 index 0000000000..e5810389be --- /dev/null +++ b/scripts/lib/devtool/build_image.py @@ -0,0 +1,174 @@ +# Development tool - build-image plugin +# +# Copyright (C) 2015 Intel Corporation +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +"""Devtool plugin containing the build-image subcommand.""" + +import os +import errno +import logging + +from bb.process import ExecutionError +from devtool import exec_build_env_command, setup_tinfoil, parse_recipe, DevtoolError + +logger = logging.getLogger('devtool') + +class TargetNotImageError(Exception): + pass + +def _get_packages(tinfoil, workspace, config): + """Get list of packages from recipes in the workspace.""" + result = [] + for recipe in workspace: + data = parse_recipe(config, tinfoil, recipe, True) + if 'class-target' in data.getVar('OVERRIDES').split(':'): + if recipe in data.getVar('PACKAGES').split(): + result.append(recipe) + else: + logger.warning("Skipping recipe %s as it doesn't produce a " + "package with the same name", recipe) + return result + +def build_image(args, config, basepath, workspace): + """Entry point for the devtool 'build-image' subcommand.""" + + image = args.imagename + auto_image = False + if not image: + sdk_targets = config.get('SDK', 'sdk_targets', '').split() + if sdk_targets: + image = sdk_targets[0] + auto_image = True + if not image: + raise DevtoolError('Unable to determine image to build, please specify one') + + try: + if args.add_packages: + add_packages = args.add_packages.split(',') + else: + add_packages = None + result, outputdir = build_image_task(config, basepath, workspace, image, add_packages) + except TargetNotImageError: + if auto_image: + raise DevtoolError('Unable to determine image to build, please specify one') + else: + raise DevtoolError('Specified recipe %s is not an image recipe' % image) + + if result == 0: + logger.info('Successfully built %s. You can find output files in %s' + % (image, outputdir)) + return result + +def build_image_task(config, basepath, workspace, image, add_packages=None, task=None, extra_append=None): + # remove <image>.bbappend to make sure setup_tinfoil doesn't + # break because of it + target_basename = config.get('SDK', 'target_basename', '') + if target_basename: + appendfile = os.path.join(config.workspace_path, 'appends', + '%s.bbappend' % target_basename) + try: + os.unlink(appendfile) + except OSError as exc: + if exc.errno != errno.ENOENT: + raise + + tinfoil = setup_tinfoil(basepath=basepath) + try: + rd = parse_recipe(config, tinfoil, image, True) + if not rd: + # Error already shown + return (1, None) + if not bb.data.inherits_class('image', rd): + raise TargetNotImageError() + + # Get the actual filename used and strip the .bb and full path + target_basename = rd.getVar('FILE') + target_basename = os.path.splitext(os.path.basename(target_basename))[0] + config.set('SDK', 'target_basename', target_basename) + config.write() + + appendfile = os.path.join(config.workspace_path, 'appends', + '%s.bbappend' % target_basename) + + outputdir = None + try: + if workspace or add_packages: + if add_packages: + packages = add_packages + else: + packages = _get_packages(tinfoil, workspace, config) + else: + packages = None + if not task: + if not packages and not add_packages and workspace: + logger.warning('No recipes in workspace, building image %s unmodified', image) + elif not packages: + logger.warning('No packages to add, building image %s unmodified', image) + + if packages or extra_append: + bb.utils.mkdirhier(os.path.dirname(appendfile)) + with open(appendfile, 'w') as afile: + if packages: + # include packages from workspace recipes into the image + afile.write('IMAGE_INSTALL_append = " %s"\n' % ' '.join(packages)) + if not task: + logger.info('Building image %s with the following ' + 'additional packages: %s', image, ' '.join(packages)) + if extra_append: + for line in extra_append: + afile.write('%s\n' % line) + + if task in ['populate_sdk', 'populate_sdk_ext']: + outputdir = rd.getVar('SDK_DEPLOY') + else: + outputdir = rd.getVar('DEPLOY_DIR_IMAGE') + + tmp_tinfoil = tinfoil + tinfoil = None + tmp_tinfoil.shutdown() + + options = '' + if task: + options += '-c %s' % task + + # run bitbake to build image (or specified task) + try: + exec_build_env_command(config.init_path, basepath, + 'bitbake %s %s' % (options, image), watch=True) + except ExecutionError as err: + return (err.exitcode, None) + finally: + if os.path.isfile(appendfile): + os.unlink(appendfile) + finally: + if tinfoil: + tinfoil.shutdown() + return (0, outputdir) + + +def register_commands(subparsers, context): + """Register devtool subcommands from the build-image plugin""" + parser = subparsers.add_parser('build-image', + help='Build image including workspace recipe packages', + description='Builds an image, extending it to include ' + 'packages from recipes in the workspace', + group='testbuild', order=-10) + parser.add_argument('imagename', help='Image recipe to build', nargs='?') + parser.add_argument('-p', '--add-packages', help='Instead of adding packages for the ' + 'entire workspace, specify packages to be added to the image ' + '(separate multiple packages by commas)', + metavar='PACKAGES') + parser.set_defaults(func=build_image) diff --git a/scripts/lib/devtool/build_sdk.py b/scripts/lib/devtool/build_sdk.py new file mode 100644 index 0000000000..b89d65b0cb --- /dev/null +++ b/scripts/lib/devtool/build_sdk.py @@ -0,0 +1,65 @@ +# Development tool - build-sdk command plugin +# +# Copyright (C) 2015-2016 Intel Corporation +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +import os +import subprocess +import logging +import glob +import shutil +import errno +import sys +import tempfile +from devtool import exec_build_env_command, setup_tinfoil, parse_recipe, DevtoolError +from devtool import build_image + +logger = logging.getLogger('devtool') + + +def build_sdk(args, config, basepath, workspace): + """Entry point for the devtool build-sdk command""" + + sdk_targets = config.get('SDK', 'sdk_targets', '').split() + if sdk_targets: + image = sdk_targets[0] + else: + raise DevtoolError('Unable to determine image to build SDK for') + + extra_append = ['SDK_DERIVATIVE = "1"'] + try: + result, outputdir = build_image.build_image_task(config, + basepath, + workspace, + image, + task='populate_sdk_ext', + extra_append=extra_append) + except build_image.TargetNotImageError: + raise DevtoolError('Unable to determine image to build SDK for') + + if result == 0: + logger.info('Successfully built SDK. You can find output files in %s' + % outputdir) + return result + + +def register_commands(subparsers, context): + """Register devtool subcommands""" + if context.fixed_setup: + parser_build_sdk = subparsers.add_parser('build-sdk', + help='Build a derivative SDK of this one', + description='Builds an extensible SDK based upon this one and the items in your workspace', + group='advanced') + parser_build_sdk.set_defaults(func=build_sdk) diff --git a/scripts/lib/devtool/deploy.py b/scripts/lib/devtool/deploy.py new file mode 100644 index 0000000000..b3730ae833 --- /dev/null +++ b/scripts/lib/devtool/deploy.py @@ -0,0 +1,325 @@ +# Development tool - deploy/undeploy command plugin +# +# Copyright (C) 2014-2016 Intel Corporation +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +"""Devtool plugin containing the deploy subcommands""" + +import os +import subprocess +import logging +import tempfile +import shutil +import argparse_oe +from devtool import exec_fakeroot, setup_tinfoil, check_workspace_recipe, DevtoolError + +logger = logging.getLogger('devtool') + +deploylist_path = '/.devtool' + +def _prepare_remote_script(deploy, verbose=False, dryrun=False, undeployall=False, nopreserve=False, nocheckspace=False): + """ + Prepare a shell script for running on the target to + deploy/undeploy files. We have to be careful what we put in this + script - only commands that are likely to be available on the + target are suitable (the target might be constrained, e.g. using + busybox rather than bash with coreutils). + """ + lines = [] + lines.append('#!/bin/sh') + lines.append('set -e') + if undeployall: + # Yes, I know this is crude - but it does work + lines.append('for entry in %s/*.list; do' % deploylist_path) + lines.append('[ ! -f $entry ] && exit') + lines.append('set `basename $entry | sed "s/.list//"`') + if dryrun: + if not deploy: + lines.append('echo "Previously deployed files for $1:"') + lines.append('manifest="%s/$1.list"' % deploylist_path) + lines.append('preservedir="%s/$1.preserve"' % deploylist_path) + lines.append('if [ -f $manifest ] ; then') + # Read manifest in reverse and delete files / remove empty dirs + lines.append(' sed \'1!G;h;$!d\' $manifest | while read file') + lines.append(' do') + if dryrun: + lines.append(' if [ ! -d $file ] ; then') + lines.append(' echo $file') + lines.append(' fi') + else: + lines.append(' if [ -d $file ] ; then') + # Avoid deleting a preserved directory in case it has special perms + lines.append(' if [ ! -d $preservedir/$file ] ; then') + lines.append(' rmdir $file > /dev/null 2>&1 || true') + lines.append(' fi') + lines.append(' else') + lines.append(' rm $file') + lines.append(' fi') + lines.append(' done') + if not dryrun: + lines.append(' rm $manifest') + if not deploy and not dryrun: + # May as well remove all traces + lines.append(' rmdir `dirname $manifest` > /dev/null 2>&1 || true') + lines.append('fi') + + if deploy: + if not nocheckspace: + # Check for available space + # FIXME This doesn't take into account files spread across multiple + # partitions, but doing that is non-trivial + # Find the part of the destination path that exists + lines.append('checkpath="$2"') + lines.append('while [ "$checkpath" != "/" ] && [ ! -e $checkpath ]') + lines.append('do') + lines.append(' checkpath=`dirname "$checkpath"`') + lines.append('done') + lines.append(r'freespace=$(df -P $checkpath | sed -nre "s/^(\S+\s+){3}([0-9]+).*/\2/p")') + # First line of the file is the total space + lines.append('total=`head -n1 $3`') + lines.append('if [ $total -gt $freespace ] ; then') + lines.append(' echo "ERROR: insufficient space on target (available ${freespace}, needed ${total})"') + lines.append(' exit 1') + lines.append('fi') + if not nopreserve: + # Preserve any files that exist. Note that this will add to the + # preserved list with successive deployments if the list of files + # deployed changes, but because we've deleted any previously + # deployed files at this point it will never preserve anything + # that was deployed, only files that existed prior to any deploying + # (which makes the most sense) + lines.append('cat $3 | sed "1d" | while read file fsize') + lines.append('do') + lines.append(' if [ -e $file ] ; then') + lines.append(' dest="$preservedir/$file"') + lines.append(' mkdir -p `dirname $dest`') + lines.append(' mv $file $dest') + lines.append(' fi') + lines.append('done') + lines.append('rm $3') + lines.append('mkdir -p `dirname $manifest`') + lines.append('mkdir -p $2') + if verbose: + lines.append(' tar xv -C $2 -f - | tee $manifest') + else: + lines.append(' tar xv -C $2 -f - > $manifest') + lines.append('sed -i "s!^./!$2!" $manifest') + elif not dryrun: + # Put any preserved files back + lines.append('if [ -d $preservedir ] ; then') + lines.append(' cd $preservedir') + lines.append(' find . -type f -exec mv {} /{} \;') + lines.append(' cd /') + lines.append(' rm -rf $preservedir') + lines.append('fi') + + if undeployall: + if not dryrun: + lines.append('echo "NOTE: Successfully undeployed $1"') + lines.append('done') + + # Delete the script itself + lines.append('rm $0') + lines.append('') + + return '\n'.join(lines) + + +def deploy(args, config, basepath, workspace): + """Entry point for the devtool 'deploy' subcommand""" + import re + import math + import oe.recipeutils + + check_workspace_recipe(workspace, args.recipename, checksrc=False) + + try: + host, destdir = args.target.split(':') + except ValueError: + destdir = '/' + else: + args.target = host + if not destdir.endswith('/'): + destdir += '/' + + tinfoil = setup_tinfoil(basepath=basepath) + try: + try: + rd = tinfoil.parse_recipe(args.recipename) + except Exception as e: + raise DevtoolError('Exception parsing recipe %s: %s' % + (args.recipename, e)) + recipe_outdir = rd.getVar('D') + if not os.path.exists(recipe_outdir) or not os.listdir(recipe_outdir): + raise DevtoolError('No files to deploy - have you built the %s ' + 'recipe? If so, the install step has not installed ' + 'any files.' % args.recipename) + + filelist = [] + ftotalsize = 0 + for root, _, files in os.walk(recipe_outdir): + for fn in files: + # Get the size in kiB (since we'll be comparing it to the output of du -k) + # MUST use lstat() here not stat() or getfilesize() since we don't want to + # dereference symlinks + fsize = int(math.ceil(float(os.lstat(os.path.join(root, fn)).st_size)/1024)) + ftotalsize += fsize + # The path as it would appear on the target + fpath = os.path.join(destdir, os.path.relpath(root, recipe_outdir), fn) + filelist.append((fpath, fsize)) + + if args.dry_run: + print('Files to be deployed for %s on target %s:' % (args.recipename, args.target)) + for item, _ in filelist: + print(' %s' % item) + return 0 + + + extraoptions = '' + if args.no_host_check: + extraoptions += '-o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no' + if not args.show_status: + extraoptions += ' -q' + + scp_port = '' + ssh_port = '' + if not args.port: + raise DevtoolError("If you specify -P/--port then you must provide the port to be used to connect to the target") + else: + scp_port = "-P %s" % args.port + ssh_port = "-p %s" % args.port + + # In order to delete previously deployed files and have the manifest file on + # the target, we write out a shell script and then copy it to the target + # so we can then run it (piping tar output to it). + # (We cannot use scp here, because it doesn't preserve symlinks.) + tmpdir = tempfile.mkdtemp(prefix='devtool') + try: + tmpscript = '/tmp/devtool_deploy.sh' + tmpfilelist = os.path.join(os.path.dirname(tmpscript), 'devtool_deploy.list') + shellscript = _prepare_remote_script(deploy=True, + verbose=args.show_status, + nopreserve=args.no_preserve, + nocheckspace=args.no_check_space) + # Write out the script to a file + with open(os.path.join(tmpdir, os.path.basename(tmpscript)), 'w') as f: + f.write(shellscript) + # Write out the file list + with open(os.path.join(tmpdir, os.path.basename(tmpfilelist)), 'w') as f: + f.write('%d\n' % ftotalsize) + for fpath, fsize in filelist: + f.write('%s %d\n' % (fpath, fsize)) + # Copy them to the target + ret = subprocess.call("scp %s %s %s/* %s:%s" % (scp_port, extraoptions, tmpdir, args.target, os.path.dirname(tmpscript)), shell=True) + if ret != 0: + raise DevtoolError('Failed to copy script to %s - rerun with -s to ' + 'get a complete error message' % args.target) + finally: + shutil.rmtree(tmpdir) + + # Now run the script + ret = exec_fakeroot(rd, 'tar cf - . | ssh %s %s %s \'sh %s %s %s %s\'' % (ssh_port, extraoptions, args.target, tmpscript, args.recipename, destdir, tmpfilelist), cwd=recipe_outdir, shell=True) + if ret != 0: + raise DevtoolError('Deploy failed - rerun with -s to get a complete ' + 'error message') + + logger.info('Successfully deployed %s' % recipe_outdir) + + files_list = [] + for root, _, files in os.walk(recipe_outdir): + for filename in files: + filename = os.path.relpath(os.path.join(root, filename), recipe_outdir) + files_list.append(os.path.join(destdir, filename)) + finally: + tinfoil.shutdown() + + return 0 + +def undeploy(args, config, basepath, workspace): + """Entry point for the devtool 'undeploy' subcommand""" + if args.all and args.recipename: + raise argparse_oe.ArgumentUsageError('Cannot specify -a/--all with a recipe name', 'undeploy-target') + elif not args.recipename and not args.all: + raise argparse_oe.ArgumentUsageError('If you don\'t specify a recipe, you must specify -a/--all', 'undeploy-target') + + extraoptions = '' + if args.no_host_check: + extraoptions += '-o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no' + if not args.show_status: + extraoptions += ' -q' + + scp_port = '' + ssh_port = '' + if not args.port: + raise DevtoolError("If you specify -P/--port then you must provide the port to be used to connect to the target") + else: + scp_port = "-P %s" % args.port + ssh_port = "-p %s" % args.port + + args.target = args.target.split(':')[0] + + tmpdir = tempfile.mkdtemp(prefix='devtool') + try: + tmpscript = '/tmp/devtool_undeploy.sh' + shellscript = _prepare_remote_script(deploy=False, dryrun=args.dry_run, undeployall=args.all) + # Write out the script to a file + with open(os.path.join(tmpdir, os.path.basename(tmpscript)), 'w') as f: + f.write(shellscript) + # Copy it to the target + ret = subprocess.call("scp %s %s %s/* %s:%s" % (scp_port, extraoptions, tmpdir, args.target, os.path.dirname(tmpscript)), shell=True) + if ret != 0: + raise DevtoolError('Failed to copy script to %s - rerun with -s to ' + 'get a complete error message' % args.target) + finally: + shutil.rmtree(tmpdir) + + # Now run the script + ret = subprocess.call('ssh %s %s %s \'sh %s %s\'' % (ssh_port, extraoptions, args.target, tmpscript, args.recipename), shell=True) + if ret != 0: + raise DevtoolError('Undeploy failed - rerun with -s to get a complete ' + 'error message') + + if not args.all and not args.dry_run: + logger.info('Successfully undeployed %s' % args.recipename) + return 0 + + +def register_commands(subparsers, context): + """Register devtool subcommands from the deploy plugin""" + parser_deploy = subparsers.add_parser('deploy-target', + help='Deploy recipe output files to live target machine', + description='Deploys a recipe\'s build output (i.e. the output of the do_install task) to a live target machine over ssh. By default, any existing files will be preserved instead of being overwritten and will be restored if you run devtool undeploy-target. Note: this only deploys the recipe itself and not any runtime dependencies, so it is assumed that those have been installed on the target beforehand.', + group='testbuild') + parser_deploy.add_argument('recipename', help='Recipe to deploy') + parser_deploy.add_argument('target', help='Live target machine running an ssh server: user@hostname[:destdir]') + parser_deploy.add_argument('-c', '--no-host-check', help='Disable ssh host key checking', action='store_true') + parser_deploy.add_argument('-s', '--show-status', help='Show progress/status output', action='store_true') + parser_deploy.add_argument('-n', '--dry-run', help='List files to be deployed only', action='store_true') + parser_deploy.add_argument('-p', '--no-preserve', help='Do not preserve existing files', action='store_true') + parser_deploy.add_argument('--no-check-space', help='Do not check for available space before deploying', action='store_true') + parser_deploy.add_argument('-P', '--port', default='22', help='Port to use for connection to the target') + parser_deploy.set_defaults(func=deploy) + + parser_undeploy = subparsers.add_parser('undeploy-target', + help='Undeploy recipe output files in live target machine', + description='Un-deploys recipe output files previously deployed to a live target machine by devtool deploy-target.', + group='testbuild') + parser_undeploy.add_argument('recipename', help='Recipe to undeploy (if not using -a/--all)', nargs='?') + parser_undeploy.add_argument('target', help='Live target machine running an ssh server: user@hostname') + parser_undeploy.add_argument('-c', '--no-host-check', help='Disable ssh host key checking', action='store_true') + parser_undeploy.add_argument('-s', '--show-status', help='Show progress/status output', action='store_true') + parser_undeploy.add_argument('-a', '--all', help='Undeploy all recipes deployed on the target', action='store_true') + parser_undeploy.add_argument('-n', '--dry-run', help='List files to be undeployed only', action='store_true') + parser_undeploy.add_argument('-P', '--port', default='22', help='Port to use for connection to the target') + parser_undeploy.set_defaults(func=undeploy) diff --git a/scripts/lib/devtool/package.py b/scripts/lib/devtool/package.py new file mode 100644 index 0000000000..af9e8f15f5 --- /dev/null +++ b/scripts/lib/devtool/package.py @@ -0,0 +1,60 @@ +# Development tool - package command plugin +# +# Copyright (C) 2014-2015 Intel Corporation +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +"""Devtool plugin containing the package subcommands""" + +import os +import subprocess +import logging +from bb.process import ExecutionError +from devtool import exec_build_env_command, setup_tinfoil, check_workspace_recipe, DevtoolError + +logger = logging.getLogger('devtool') + +def package(args, config, basepath, workspace): + """Entry point for the devtool 'package' subcommand""" + check_workspace_recipe(workspace, args.recipename) + + tinfoil = setup_tinfoil(basepath=basepath, config_only=True) + try: + image_pkgtype = config.get('Package', 'image_pkgtype', '') + if not image_pkgtype: + image_pkgtype = tinfoil.config_data.getVar('IMAGE_PKGTYPE') + + deploy_dir_pkg = tinfoil.config_data.getVar('DEPLOY_DIR_%s' % image_pkgtype.upper()) + finally: + tinfoil.shutdown() + + package_task = config.get('Package', 'package_task', 'package_write_%s' % image_pkgtype) + try: + exec_build_env_command(config.init_path, basepath, 'bitbake -c %s %s' % (package_task, args.recipename), watch=True) + except bb.process.ExecutionError as e: + # We've already seen the output since watch=True, so just ensure we return something to the user + return e.exitcode + + logger.info('Your packages are in %s' % deploy_dir_pkg) + + return 0 + +def register_commands(subparsers, context): + """Register devtool subcommands from the package plugin""" + if context.fixed_setup: + parser_package = subparsers.add_parser('package', + help='Build packages for a recipe', + description='Builds packages for a recipe\'s output files', + group='testbuild', order=-5) + parser_package.add_argument('recipename', help='Recipe to package') + parser_package.set_defaults(func=package) diff --git a/scripts/lib/devtool/runqemu.py b/scripts/lib/devtool/runqemu.py new file mode 100644 index 0000000000..e26cf28c2f --- /dev/null +++ b/scripts/lib/devtool/runqemu.py @@ -0,0 +1,74 @@ +# Development tool - runqemu command plugin +# +# Copyright (C) 2015 Intel Corporation +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +"""Devtool runqemu plugin""" + +import os +import bb +import logging +import argparse +import glob +from devtool import exec_build_env_command, setup_tinfoil, DevtoolError + +logger = logging.getLogger('devtool') + +def runqemu(args, config, basepath, workspace): + """Entry point for the devtool 'runqemu' subcommand""" + + tinfoil = setup_tinfoil(config_only=True, basepath=basepath) + try: + machine = tinfoil.config_data.getVar('MACHINE') + bindir_native = os.path.join(tinfoil.config_data.getVar('STAGING_DIR'), + tinfoil.config_data.getVar('BUILD_ARCH'), + tinfoil.config_data.getVar('bindir_native').lstrip(os.path.sep)) + finally: + tinfoil.shutdown() + + if not glob.glob(os.path.join(bindir_native, 'qemu-system-*')): + raise DevtoolError('QEMU is not available within this SDK') + + imagename = args.imagename + if not imagename: + sdk_targets = config.get('SDK', 'sdk_targets', '').split() + if sdk_targets: + imagename = sdk_targets[0] + if not imagename: + raise DevtoolError('Unable to determine image name to run, please specify one') + + try: + # FIXME runqemu assumes that if OECORE_NATIVE_SYSROOT is set then it shouldn't + # run bitbake to find out the values of various environment variables, which + # isn't the case for the extensible SDK. Work around it for now. + newenv = dict(os.environ) + newenv.pop('OECORE_NATIVE_SYSROOT', '') + exec_build_env_command(config.init_path, basepath, 'runqemu %s %s %s' % (machine, imagename, " ".join(args.args)), watch=True, env=newenv) + except bb.process.ExecutionError as e: + # We've already seen the output since watch=True, so just ensure we return something to the user + return e.exitcode + + return 0 + +def register_commands(subparsers, context): + """Register devtool subcommands from this plugin""" + if context.fixed_setup: + parser_runqemu = subparsers.add_parser('runqemu', help='Run QEMU on the specified image', + description='Runs QEMU to boot the specified image', + group='testbuild', order=-20) + parser_runqemu.add_argument('imagename', help='Name of built image to boot within QEMU', nargs='?') + parser_runqemu.add_argument('args', help='Any remaining arguments are passed to the runqemu script (pass --help after imagename to see what these are)', + nargs=argparse.REMAINDER) + parser_runqemu.set_defaults(func=runqemu) diff --git a/scripts/lib/devtool/sdk.py b/scripts/lib/devtool/sdk.py new file mode 100644 index 0000000000..e8bf0ad98c --- /dev/null +++ b/scripts/lib/devtool/sdk.py @@ -0,0 +1,336 @@ +# Development tool - sdk-update command plugin +# +# Copyright (C) 2015-2016 Intel Corporation +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +import os +import subprocess +import logging +import glob +import shutil +import errno +import sys +import tempfile +import re +from devtool import exec_build_env_command, setup_tinfoil, parse_recipe, DevtoolError + +logger = logging.getLogger('devtool') + +def parse_locked_sigs(sigfile_path): + """Return <pn:task>:<hash> dictionary""" + sig_dict = {} + with open(sigfile_path) as f: + lines = f.readlines() + for line in lines: + if ':' in line: + taskkey, _, hashval = line.rpartition(':') + sig_dict[taskkey.strip()] = hashval.split()[0] + return sig_dict + +def generate_update_dict(sigfile_new, sigfile_old): + """Return a dict containing <pn:task>:<hash> which indicates what need to be updated""" + update_dict = {} + sigdict_new = parse_locked_sigs(sigfile_new) + sigdict_old = parse_locked_sigs(sigfile_old) + for k in sigdict_new: + if k not in sigdict_old: + update_dict[k] = sigdict_new[k] + continue + if sigdict_new[k] != sigdict_old[k]: + update_dict[k] = sigdict_new[k] + continue + return update_dict + +def get_sstate_objects(update_dict, sstate_dir): + """Return a list containing sstate objects which are to be installed""" + sstate_objects = [] + for k in update_dict: + files = set() + hashval = update_dict[k] + p = sstate_dir + '/' + hashval[:2] + '/*' + hashval + '*.tgz' + files |= set(glob.glob(p)) + p = sstate_dir + '/*/' + hashval[:2] + '/*' + hashval + '*.tgz' + files |= set(glob.glob(p)) + files = list(files) + if len(files) == 1: + sstate_objects.extend(files) + elif len(files) > 1: + logger.error("More than one matching sstate object found for %s" % hashval) + + return sstate_objects + +def mkdir(d): + try: + os.makedirs(d) + except OSError as e: + if e.errno != errno.EEXIST: + raise e + +def install_sstate_objects(sstate_objects, src_sdk, dest_sdk): + """Install sstate objects into destination SDK""" + sstate_dir = os.path.join(dest_sdk, 'sstate-cache') + if not os.path.exists(sstate_dir): + logger.error("Missing sstate-cache directory in %s, it might not be an extensible SDK." % dest_sdk) + raise + for sb in sstate_objects: + dst = sb.replace(src_sdk, dest_sdk) + destdir = os.path.dirname(dst) + mkdir(destdir) + logger.debug("Copying %s to %s" % (sb, dst)) + shutil.copy(sb, dst) + +def check_manifest(fn, basepath): + import bb.utils + changedfiles = [] + with open(fn, 'r') as f: + for line in f: + splitline = line.split() + if len(splitline) > 1: + chksum = splitline[0] + fpath = splitline[1] + curr_chksum = bb.utils.sha256_file(os.path.join(basepath, fpath)) + if chksum != curr_chksum: + logger.debug('File %s changed: old csum = %s, new = %s' % (os.path.join(basepath, fpath), curr_chksum, chksum)) + changedfiles.append(fpath) + return changedfiles + +def sdk_update(args, config, basepath, workspace): + """Entry point for devtool sdk-update command""" + updateserver = args.updateserver + if not updateserver: + updateserver = config.get('SDK', 'updateserver', '') + logger.debug("updateserver: %s" % updateserver) + + # Make sure we are using sdk-update from within SDK + logger.debug("basepath = %s" % basepath) + old_locked_sig_file_path = os.path.join(basepath, 'conf/locked-sigs.inc') + if not os.path.exists(old_locked_sig_file_path): + logger.error("Not using devtool's sdk-update command from within an extensible SDK. Please specify correct basepath via --basepath option") + return -1 + else: + logger.debug("Found conf/locked-sigs.inc in %s" % basepath) + + if not '://' in updateserver: + logger.error("Update server must be a URL") + return -1 + + layers_dir = os.path.join(basepath, 'layers') + conf_dir = os.path.join(basepath, 'conf') + + # Grab variable values + tinfoil = setup_tinfoil(config_only=True, basepath=basepath) + try: + stamps_dir = tinfoil.config_data.getVar('STAMPS_DIR') + sstate_mirrors = tinfoil.config_data.getVar('SSTATE_MIRRORS') + site_conf_version = tinfoil.config_data.getVar('SITE_CONF_VERSION') + finally: + tinfoil.shutdown() + + tmpsdk_dir = tempfile.mkdtemp() + try: + os.makedirs(os.path.join(tmpsdk_dir, 'conf')) + new_locked_sig_file_path = os.path.join(tmpsdk_dir, 'conf', 'locked-sigs.inc') + # Fetch manifest from server + tmpmanifest = os.path.join(tmpsdk_dir, 'conf', 'sdk-conf-manifest') + ret = subprocess.call("wget -q -O %s %s/conf/sdk-conf-manifest" % (tmpmanifest, updateserver), shell=True) + changedfiles = check_manifest(tmpmanifest, basepath) + if not changedfiles: + logger.info("Already up-to-date") + return 0 + # Update metadata + logger.debug("Updating metadata via git ...") + #Check for the status before doing a fetch and reset + if os.path.exists(os.path.join(basepath, 'layers/.git')): + out = subprocess.check_output("git status --porcelain", shell=True, cwd=layers_dir) + if not out: + ret = subprocess.call("git fetch --all; git reset --hard", shell=True, cwd=layers_dir) + else: + logger.error("Failed to update metadata as there have been changes made to it. Aborting."); + logger.error("Changed files:\n%s" % out); + return -1 + else: + ret = -1 + if ret != 0: + ret = subprocess.call("git clone %s/layers/.git" % updateserver, shell=True, cwd=tmpsdk_dir) + if ret != 0: + logger.error("Updating metadata via git failed") + return ret + logger.debug("Updating conf files ...") + for changedfile in changedfiles: + ret = subprocess.call("wget -q -O %s %s/%s" % (changedfile, updateserver, changedfile), shell=True, cwd=tmpsdk_dir) + if ret != 0: + logger.error("Updating %s failed" % changedfile) + return ret + + # Check if UNINATIVE_CHECKSUM changed + uninative = False + if 'conf/local.conf' in changedfiles: + def read_uninative_checksums(fn): + chksumitems = [] + with open(fn, 'r') as f: + for line in f: + if line.startswith('UNINATIVE_CHECKSUM'): + splitline = re.split(r'[\[\]"\']', line) + if len(splitline) > 3: + chksumitems.append((splitline[1], splitline[3])) + return chksumitems + + oldsums = read_uninative_checksums(os.path.join(basepath, 'conf/local.conf')) + newsums = read_uninative_checksums(os.path.join(tmpsdk_dir, 'conf/local.conf')) + if oldsums != newsums: + uninative = True + for buildarch, chksum in newsums: + uninative_file = os.path.join('downloads', 'uninative', chksum, '%s-nativesdk-libc.tar.bz2' % buildarch) + mkdir(os.path.join(tmpsdk_dir, os.path.dirname(uninative_file))) + ret = subprocess.call("wget -q -O %s %s/%s" % (uninative_file, updateserver, uninative_file), shell=True, cwd=tmpsdk_dir) + + # Ok, all is well at this point - move everything over + tmplayers_dir = os.path.join(tmpsdk_dir, 'layers') + if os.path.exists(tmplayers_dir): + shutil.rmtree(layers_dir) + shutil.move(tmplayers_dir, layers_dir) + for changedfile in changedfiles: + destfile = os.path.join(basepath, changedfile) + os.remove(destfile) + shutil.move(os.path.join(tmpsdk_dir, changedfile), destfile) + os.remove(os.path.join(conf_dir, 'sdk-conf-manifest')) + shutil.move(tmpmanifest, conf_dir) + if uninative: + shutil.rmtree(os.path.join(basepath, 'downloads', 'uninative')) + shutil.move(os.path.join(tmpsdk_dir, 'downloads', 'uninative'), os.path.join(basepath, 'downloads')) + + if not sstate_mirrors: + with open(os.path.join(conf_dir, 'site.conf'), 'a') as f: + f.write('SCONF_VERSION = "%s"\n' % site_conf_version) + f.write('SSTATE_MIRRORS_append = " file://.* %s/sstate-cache/PATH \\n "\n' % updateserver) + finally: + shutil.rmtree(tmpsdk_dir) + + if not args.skip_prepare: + # Find all potentially updateable tasks + sdk_update_targets = [] + tasks = ['do_populate_sysroot', 'do_packagedata'] + for root, _, files in os.walk(stamps_dir): + for fn in files: + if not '.sigdata.' in fn: + for task in tasks: + if '.%s.' % task in fn or '.%s_setscene.' % task in fn: + sdk_update_targets.append('%s:%s' % (os.path.basename(root), task)) + # Run bitbake command for the whole SDK + logger.info("Preparing build system... (This may take some time.)") + try: + exec_build_env_command(config.init_path, basepath, 'bitbake --setscene-only %s' % ' '.join(sdk_update_targets), stderr=subprocess.STDOUT) + output, _ = exec_build_env_command(config.init_path, basepath, 'bitbake -n %s' % ' '.join(sdk_update_targets), stderr=subprocess.STDOUT) + runlines = [] + for line in output.splitlines(): + if 'Running task ' in line: + runlines.append(line) + if runlines: + logger.error('Unexecuted tasks found in preparation log:\n %s' % '\n '.join(runlines)) + return -1 + except bb.process.ExecutionError as e: + logger.error('Preparation failed:\n%s' % e.stdout) + return -1 + return 0 + +def sdk_install(args, config, basepath, workspace): + """Entry point for the devtool sdk-install command""" + + import oe.recipeutils + import bb.process + + for recipe in args.recipename: + if recipe in workspace: + raise DevtoolError('recipe %s is a recipe in your workspace' % recipe) + + tasks = ['do_populate_sysroot', 'do_packagedata'] + stampprefixes = {} + def checkstamp(recipe): + stampprefix = stampprefixes[recipe] + stamps = glob.glob(stampprefix + '*') + for stamp in stamps: + if '.sigdata.' not in stamp and stamp.startswith((stampprefix + '.', stampprefix + '_setscene.')): + return True + else: + return False + + install_recipes = [] + tinfoil = setup_tinfoil(config_only=False, basepath=basepath) + try: + for recipe in args.recipename: + rd = parse_recipe(config, tinfoil, recipe, True) + if not rd: + return 1 + stampprefixes[recipe] = '%s.%s' % (rd.getVar('STAMP'), tasks[0]) + if checkstamp(recipe): + logger.info('%s is already installed' % recipe) + else: + install_recipes.append(recipe) + finally: + tinfoil.shutdown() + + if install_recipes: + logger.info('Installing %s...' % ', '.join(install_recipes)) + install_tasks = [] + for recipe in install_recipes: + for task in tasks: + if recipe.endswith('-native') and 'package' in task: + continue + install_tasks.append('%s:%s' % (recipe, task)) + options = '' + if not args.allow_build: + options += ' --setscene-only' + try: + exec_build_env_command(config.init_path, basepath, 'bitbake %s %s' % (options, ' '.join(install_tasks)), watch=True) + except bb.process.ExecutionError as e: + raise DevtoolError('Failed to install %s:\n%s' % (recipe, str(e))) + failed = False + for recipe in install_recipes: + if checkstamp(recipe): + logger.info('Successfully installed %s' % recipe) + else: + raise DevtoolError('Failed to install %s - unavailable' % recipe) + failed = True + if failed: + return 2 + + try: + exec_build_env_command(config.init_path, basepath, 'bitbake build-sysroots', watch=True) + except bb.process.ExecutionError as e: + raise DevtoolError('Failed to bitbake build-sysroots:\n%s' % (str(e))) + + +def register_commands(subparsers, context): + """Register devtool subcommands from the sdk plugin""" + if context.fixed_setup: + parser_sdk = subparsers.add_parser('sdk-update', + help='Update SDK components', + description='Updates installed SDK components from a remote server', + group='sdk') + updateserver = context.config.get('SDK', 'updateserver', '') + if updateserver: + parser_sdk.add_argument('updateserver', help='The update server to fetch latest SDK components from (default %s)' % updateserver, nargs='?') + else: + parser_sdk.add_argument('updateserver', help='The update server to fetch latest SDK components from') + parser_sdk.add_argument('--skip-prepare', action="store_true", help='Skip re-preparing the build system after updating (for debugging only)') + parser_sdk.set_defaults(func=sdk_update) + + parser_sdk_install = subparsers.add_parser('sdk-install', + help='Install additional SDK components', + description='Installs additional recipe development files into the SDK. (You can use "devtool search" to find available recipes.)', + group='sdk') + parser_sdk_install.add_argument('recipename', help='Name of the recipe to install the development artifacts for', nargs='+') + parser_sdk_install.add_argument('-s', '--allow-build', help='Allow building requested item(s) from source', action='store_true') + parser_sdk_install.set_defaults(func=sdk_install) diff --git a/scripts/lib/devtool/search.py b/scripts/lib/devtool/search.py new file mode 100644 index 0000000000..054985b85d --- /dev/null +++ b/scripts/lib/devtool/search.py @@ -0,0 +1,88 @@ +# Development tool - search command plugin +# +# Copyright (C) 2015 Intel Corporation +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +"""Devtool search plugin""" + +import os +import bb +import logging +import argparse +import re +from devtool import setup_tinfoil, parse_recipe, DevtoolError + +logger = logging.getLogger('devtool') + +def search(args, config, basepath, workspace): + """Entry point for the devtool 'search' subcommand""" + + tinfoil = setup_tinfoil(config_only=False, basepath=basepath) + try: + pkgdata_dir = tinfoil.config_data.getVar('PKGDATA_DIR') + defsummary = tinfoil.config_data.getVar('SUMMARY', False) or '' + + keyword_rc = re.compile(args.keyword) + + for fn in os.listdir(pkgdata_dir): + pfn = os.path.join(pkgdata_dir, fn) + if not os.path.isfile(pfn): + continue + + packages = [] + match = False + if keyword_rc.search(fn): + match = True + + if not match: + with open(pfn, 'r') as f: + for line in f: + if line.startswith('PACKAGES:'): + packages = line.split(':', 1)[1].strip().split() + + for pkg in packages: + if keyword_rc.search(pkg): + match = True + break + if os.path.exists(os.path.join(pkgdata_dir, 'runtime', pkg + '.packaged')): + with open(os.path.join(pkgdata_dir, 'runtime', pkg), 'r') as f: + for line in f: + if ': ' in line: + splitline = line.split(':', 1) + key = splitline[0] + value = splitline[1].strip() + if key in ['PKG_%s' % pkg, 'DESCRIPTION', 'FILES_INFO'] or key.startswith('FILERPROVIDES_'): + if keyword_rc.search(value): + match = True + break + + if match: + rd = parse_recipe(config, tinfoil, fn, True) + summary = rd.getVar('SUMMARY') + if summary == rd.expand(defsummary): + summary = '' + print("%s %s" % (fn.ljust(20), summary)) + finally: + tinfoil.shutdown() + + return 0 + +def register_commands(subparsers, context): + """Register devtool subcommands from this plugin""" + parser_search = subparsers.add_parser('search', help='Search available recipes', + description='Searches for available target recipes. Matches on recipe name, package name, description and installed files, and prints the recipe name on match.', + group='info') + parser_search.add_argument('keyword', help='Keyword to search for (regular expression syntax allowed)') + parser_search.set_defaults(func=search, no_workspace=True) diff --git a/scripts/lib/devtool/standard.py b/scripts/lib/devtool/standard.py new file mode 100644 index 0000000000..5ff1e230fd --- /dev/null +++ b/scripts/lib/devtool/standard.py @@ -0,0 +1,1918 @@ +# Development tool - standard commands plugin +# +# Copyright (C) 2014-2016 Intel Corporation +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +"""Devtool standard plugins""" + +import os +import sys +import re +import shutil +import subprocess +import tempfile +import logging +import argparse +import argparse_oe +import scriptutils +import errno +import glob +import filecmp +from collections import OrderedDict +from devtool import exec_build_env_command, setup_tinfoil, check_workspace_recipe, use_external_build, setup_git_repo, recipe_to_append, get_bbclassextend_targets, ensure_npm, DevtoolError +from devtool import parse_recipe + +logger = logging.getLogger('devtool') + + +def add(args, config, basepath, workspace): + """Entry point for the devtool 'add' subcommand""" + import bb + import oe.recipeutils + + if not args.recipename and not args.srctree and not args.fetch and not args.fetchuri: + raise argparse_oe.ArgumentUsageError('At least one of recipename, srctree, fetchuri or -f/--fetch must be specified', 'add') + + # These are positional arguments, but because we're nice, allow + # specifying e.g. source tree without name, or fetch URI without name or + # source tree (if we can detect that that is what the user meant) + if scriptutils.is_src_url(args.recipename): + if not args.fetchuri: + if args.fetch: + raise DevtoolError('URI specified as positional argument as well as -f/--fetch') + args.fetchuri = args.recipename + args.recipename = '' + elif scriptutils.is_src_url(args.srctree): + if not args.fetchuri: + if args.fetch: + raise DevtoolError('URI specified as positional argument as well as -f/--fetch') + args.fetchuri = args.srctree + args.srctree = '' + elif args.recipename and not args.srctree: + if os.sep in args.recipename: + args.srctree = args.recipename + args.recipename = None + elif os.path.isdir(args.recipename): + logger.warn('Ambiguous argument "%s" - assuming you mean it to be the recipe name' % args.recipename) + + if args.srctree and os.path.isfile(args.srctree): + args.fetchuri = 'file://' + os.path.abspath(args.srctree) + args.srctree = '' + + if args.fetch: + if args.fetchuri: + raise DevtoolError('URI specified as positional argument as well as -f/--fetch') + else: + logger.warn('-f/--fetch option is deprecated - you can now simply specify the URL to fetch as a positional argument instead') + args.fetchuri = args.fetch + + if args.recipename: + if args.recipename in workspace: + raise DevtoolError("recipe %s is already in your workspace" % + args.recipename) + reason = oe.recipeutils.validate_pn(args.recipename) + if reason: + raise DevtoolError(reason) + + if args.srctree: + srctree = os.path.abspath(args.srctree) + srctreeparent = None + tmpsrcdir = None + else: + srctree = None + srctreeparent = get_default_srctree(config) + bb.utils.mkdirhier(srctreeparent) + tmpsrcdir = tempfile.mkdtemp(prefix='devtoolsrc', dir=srctreeparent) + + if srctree and os.path.exists(srctree): + if args.fetchuri: + if not os.path.isdir(srctree): + raise DevtoolError("Cannot fetch into source tree path %s as " + "it exists and is not a directory" % + srctree) + elif os.listdir(srctree): + raise DevtoolError("Cannot fetch into source tree path %s as " + "it already exists and is non-empty" % + srctree) + elif not args.fetchuri: + if args.srctree: + raise DevtoolError("Specified source tree %s could not be found" % + args.srctree) + elif srctree: + raise DevtoolError("No source tree exists at default path %s - " + "either create and populate this directory, " + "or specify a path to a source tree, or a " + "URI to fetch source from" % srctree) + else: + raise DevtoolError("You must either specify a source tree " + "or a URI to fetch source from") + + if args.version: + if '_' in args.version or ' ' in args.version: + raise DevtoolError('Invalid version string "%s"' % args.version) + + if args.color == 'auto' and sys.stdout.isatty(): + color = 'always' + else: + color = args.color + extracmdopts = '' + if args.fetchuri: + if args.fetchuri.startswith('npm://'): + ensure_npm(config, basepath, args.fixed_setup) + + source = args.fetchuri + if srctree: + extracmdopts += ' -x %s' % srctree + else: + extracmdopts += ' -x %s' % tmpsrcdir + else: + source = srctree + if args.recipename: + extracmdopts += ' -N %s' % args.recipename + if args.version: + extracmdopts += ' -V %s' % args.version + if args.binary: + extracmdopts += ' -b' + if args.also_native: + extracmdopts += ' --also-native' + if args.src_subdir: + extracmdopts += ' --src-subdir "%s"' % args.src_subdir + if args.autorev: + extracmdopts += ' -a' + if args.fetch_dev: + extracmdopts += ' --fetch-dev' + + tempdir = tempfile.mkdtemp(prefix='devtool') + try: + builtnpm = False + while True: + try: + stdout, _ = exec_build_env_command(config.init_path, basepath, 'recipetool --color=%s create --devtool -o %s \'%s\' %s' % (color, tempdir, source, extracmdopts), watch=True) + except bb.process.ExecutionError as e: + if e.exitcode == 14: + if builtnpm: + raise DevtoolError('Re-running recipetool still failed to find npm') + # FIXME this is a horrible hack that is unfortunately + # necessary due to the fact that we can't run bitbake from + # inside recipetool since recipetool keeps tinfoil active + # with references to it throughout the code, so we have + # to exit out and come back here to do it. + ensure_npm(config, basepath, args.fixed_setup, check_exists=False) + logger.info('Re-running recipe creation process after building nodejs') + builtnpm = True + continue + elif e.exitcode == 15: + raise DevtoolError('Could not auto-determine recipe name, please specify it on the command line') + else: + raise DevtoolError('Command \'%s\' failed' % e.command) + break + + recipes = glob.glob(os.path.join(tempdir, '*.bb')) + if recipes: + recipename = os.path.splitext(os.path.basename(recipes[0]))[0].split('_')[0] + if recipename in workspace: + raise DevtoolError('A recipe with the same name as the one being created (%s) already exists in your workspace' % recipename) + recipedir = os.path.join(config.workspace_path, 'recipes', recipename) + bb.utils.mkdirhier(recipedir) + recipefile = os.path.join(recipedir, os.path.basename(recipes[0])) + appendfile = recipe_to_append(recipefile, config) + if os.path.exists(appendfile): + # This shouldn't be possible, but just in case + raise DevtoolError('A recipe with the same name as the one being created already exists in your workspace') + if os.path.exists(recipefile): + raise DevtoolError('A recipe file %s already exists in your workspace; this shouldn\'t be there - please delete it before continuing' % recipefile) + if tmpsrcdir: + srctree = os.path.join(srctreeparent, recipename) + if os.path.exists(tmpsrcdir): + if os.path.exists(srctree): + if os.path.isdir(srctree): + try: + os.rmdir(srctree) + except OSError as e: + if e.errno == errno.ENOTEMPTY: + raise DevtoolError('Source tree path %s already exists and is not empty' % srctree) + else: + raise + else: + raise DevtoolError('Source tree path %s already exists and is not a directory' % srctree) + logger.info('Using default source tree path %s' % srctree) + shutil.move(tmpsrcdir, srctree) + else: + raise DevtoolError('Couldn\'t find source tree created by recipetool') + bb.utils.mkdirhier(recipedir) + shutil.move(recipes[0], recipefile) + # Move any additional files created by recipetool + for fn in os.listdir(tempdir): + shutil.move(os.path.join(tempdir, fn), recipedir) + else: + raise DevtoolError('Command \'%s\' did not create any recipe file:\n%s' % (e.command, e.stdout)) + attic_recipe = os.path.join(config.workspace_path, 'attic', recipename, os.path.basename(recipefile)) + if os.path.exists(attic_recipe): + logger.warn('A modified recipe from a previous invocation exists in %s - you may wish to move this over the top of the new recipe if you had changes in it that you want to continue with' % attic_recipe) + finally: + if tmpsrcdir and os.path.exists(tmpsrcdir): + shutil.rmtree(tmpsrcdir) + shutil.rmtree(tempdir) + + for fn in os.listdir(recipedir): + _add_md5(config, recipename, os.path.join(recipedir, fn)) + + tinfoil = setup_tinfoil(config_only=True, basepath=basepath) + try: + try: + rd = tinfoil.parse_recipe_file(recipefile, False) + except Exception as e: + logger.error(str(e)) + rd = None + if not rd: + # Parsing failed. We just created this recipe and we shouldn't + # leave it in the workdir or it'll prevent bitbake from starting + movefn = '%s.parsefailed' % recipefile + logger.error('Parsing newly created recipe failed, moving recipe to %s for reference. If this looks to be caused by the recipe itself, please report this error.' % movefn) + shutil.move(recipefile, movefn) + return 1 + + if args.fetchuri and not args.no_git: + setup_git_repo(srctree, args.version, 'devtool', d=tinfoil.config_data) + + initial_rev = None + if os.path.exists(os.path.join(srctree, '.git')): + (stdout, _) = bb.process.run('git rev-parse HEAD', cwd=srctree) + initial_rev = stdout.rstrip() + + if args.src_subdir: + srctree = os.path.join(srctree, args.src_subdir) + + bb.utils.mkdirhier(os.path.dirname(appendfile)) + with open(appendfile, 'w') as f: + f.write('inherit externalsrc\n') + f.write('EXTERNALSRC = "%s"\n' % srctree) + + b_is_s = use_external_build(args.same_dir, args.no_same_dir, rd) + if b_is_s: + f.write('EXTERNALSRC_BUILD = "%s"\n' % srctree) + if initial_rev: + f.write('\n# initial_rev: %s\n' % initial_rev) + + if args.binary: + f.write('do_install_append() {\n') + f.write(' rm -rf ${D}/.git\n') + f.write(' rm -f ${D}/singletask.lock\n') + f.write('}\n') + + if bb.data.inherits_class('npm', rd): + f.write('do_install_append() {\n') + f.write(' # Remove files added to source dir by devtool/externalsrc\n') + f.write(' rm -f ${NPM_INSTALLDIR}/singletask.lock\n') + f.write(' rm -rf ${NPM_INSTALLDIR}/.git\n') + f.write(' rm -rf ${NPM_INSTALLDIR}/oe-local-files\n') + f.write(' for symlink in ${EXTERNALSRC_SYMLINKS} ; do\n') + f.write(' rm -f ${NPM_INSTALLDIR}/${symlink%%:*}\n') + f.write(' done\n') + f.write('}\n') + + _add_md5(config, recipename, appendfile) + + logger.info('Recipe %s has been automatically created; further editing may be required to make it fully functional' % recipefile) + + finally: + tinfoil.shutdown() + + return 0 + + +def _check_compatible_recipe(pn, d): + """Check if the recipe is supported by devtool""" + if pn == 'perf': + raise DevtoolError("The perf recipe does not actually check out " + "source and thus cannot be supported by this tool", + 4) + + if pn in ['kernel-devsrc', 'package-index'] or pn.startswith('gcc-source'): + raise DevtoolError("The %s recipe is not supported by this tool" % pn, 4) + + if bb.data.inherits_class('image', d): + raise DevtoolError("The %s recipe is an image, and therefore is not " + "supported by this tool" % pn, 4) + + if bb.data.inherits_class('populate_sdk', d): + raise DevtoolError("The %s recipe is an SDK, and therefore is not " + "supported by this tool" % pn, 4) + + if bb.data.inherits_class('packagegroup', d): + raise DevtoolError("The %s recipe is a packagegroup, and therefore is " + "not supported by this tool" % pn, 4) + + if bb.data.inherits_class('meta', d): + raise DevtoolError("The %s recipe is a meta-recipe, and therefore is " + "not supported by this tool" % pn, 4) + + if bb.data.inherits_class('externalsrc', d) and d.getVar('EXTERNALSRC'): + # Not an incompatibility error per se, so we don't pass the error code + raise DevtoolError("externalsrc is currently enabled for the %s " + "recipe. This prevents the normal do_patch task " + "from working. You will need to disable this " + "first." % pn) + +def _move_file(src, dst): + """Move a file. Creates all the directory components of destination path.""" + dst_d = os.path.dirname(dst) + if dst_d: + bb.utils.mkdirhier(dst_d) + shutil.move(src, dst) + +def _copy_file(src, dst): + """Copy a file. Creates all the directory components of destination path.""" + dst_d = os.path.dirname(dst) + if dst_d: + bb.utils.mkdirhier(dst_d) + shutil.copy(src, dst) + +def _git_ls_tree(repodir, treeish='HEAD', recursive=False): + """List contents of a git treeish""" + import bb + cmd = ['git', 'ls-tree', '-z', treeish] + if recursive: + cmd.append('-r') + out, _ = bb.process.run(cmd, cwd=repodir) + ret = {} + if out: + for line in out.split('\0'): + if line: + split = line.split(None, 4) + ret[split[3]] = split[0:3] + return ret + +def _git_exclude_path(srctree, path): + """Return pathspec (list of paths) that excludes certain path""" + # NOTE: "Filtering out" files/paths in this way is not entirely reliable - + # we don't catch files that are deleted, for example. A more reliable way + # to implement this would be to use "negative pathspecs" which were + # introduced in Git v1.9.0. Revisit this when/if the required Git version + # becomes greater than that. + path = os.path.normpath(path) + recurse = True if len(path.split(os.path.sep)) > 1 else False + git_files = list(_git_ls_tree(srctree, 'HEAD', recurse).keys()) + if path in git_files: + git_files.remove(path) + return git_files + else: + return ['.'] + +def _ls_tree(directory): + """Recursive listing of files in a directory""" + ret = [] + for root, dirs, files in os.walk(directory): + ret.extend([os.path.relpath(os.path.join(root, fname), directory) for + fname in files]) + return ret + + +def extract(args, config, basepath, workspace): + """Entry point for the devtool 'extract' subcommand""" + import bb + + tinfoil = _prep_extract_operation(config, basepath, args.recipename) + if not tinfoil: + # Error already shown + return 1 + try: + rd = parse_recipe(config, tinfoil, args.recipename, True) + if not rd: + return 1 + + srctree = os.path.abspath(args.srctree) + initial_rev = _extract_source(srctree, args.keep_temp, args.branch, False, rd, tinfoil) + logger.info('Source tree extracted to %s' % srctree) + + if initial_rev: + return 0 + else: + return 1 + finally: + tinfoil.shutdown() + +def sync(args, config, basepath, workspace): + """Entry point for the devtool 'sync' subcommand""" + import bb + + tinfoil = _prep_extract_operation(config, basepath, args.recipename) + if not tinfoil: + # Error already shown + return 1 + try: + rd = parse_recipe(config, tinfoil, args.recipename, True) + if not rd: + return 1 + + srctree = os.path.abspath(args.srctree) + initial_rev = _extract_source(srctree, args.keep_temp, args.branch, True, rd, tinfoil) + logger.info('Source tree %s synchronized' % srctree) + + if initial_rev: + return 0 + else: + return 1 + finally: + tinfoil.shutdown() + + +def _prep_extract_operation(config, basepath, recipename, tinfoil=None): + """HACK: Ugly workaround for making sure that requirements are met when + trying to extract a package. Returns the tinfoil instance to be used.""" + if not tinfoil: + tinfoil = setup_tinfoil(basepath=basepath) + + rd = parse_recipe(config, tinfoil, recipename, True) + if not rd: + return None + + if bb.data.inherits_class('kernel-yocto', rd): + tinfoil.shutdown() + try: + stdout, _ = exec_build_env_command(config.init_path, basepath, + 'bitbake kern-tools-native') + tinfoil = setup_tinfoil(basepath=basepath) + except bb.process.ExecutionError as err: + raise DevtoolError("Failed to build kern-tools-native:\n%s" % + err.stdout) + return tinfoil + + +def _extract_source(srctree, keep_temp, devbranch, sync, d, tinfoil): + """Extract sources of a recipe""" + import oe.recipeutils + + pn = d.getVar('PN') + + _check_compatible_recipe(pn, d) + + if sync: + if not os.path.exists(srctree): + raise DevtoolError("output path %s does not exist" % srctree) + else: + if os.path.exists(srctree): + if not os.path.isdir(srctree): + raise DevtoolError("output path %s exists and is not a directory" % + srctree) + elif os.listdir(srctree): + raise DevtoolError("output path %s already exists and is " + "non-empty" % srctree) + + if 'noexec' in (d.getVarFlags('do_unpack', False) or []): + raise DevtoolError("The %s recipe has do_unpack disabled, unable to " + "extract source" % pn, 4) + + if not sync: + # Prepare for shutil.move later on + bb.utils.mkdirhier(srctree) + os.rmdir(srctree) + + initial_rev = None + # We need to redirect WORKDIR, STAMPS_DIR etc. under a temporary + # directory so that: + # (a) we pick up all files that get unpacked to the WORKDIR, and + # (b) we don't disturb the existing build + # However, with recipe-specific sysroots the sysroots for the recipe + # will be prepared under WORKDIR, and if we used the system temporary + # directory (i.e. usually /tmp) as used by mkdtemp by default, then + # our attempts to hardlink files into the recipe-specific sysroots + # will fail on systems where /tmp is a different filesystem, and it + # would have to fall back to copying the files which is a waste of + # time. Put the temp directory under the WORKDIR to prevent that from + # being a problem. + tempbasedir = d.getVar('WORKDIR') + bb.utils.mkdirhier(tempbasedir) + tempdir = tempfile.mkdtemp(prefix='devtooltmp-', dir=tempbasedir) + try: + tinfoil.logger.setLevel(logging.WARNING) + + crd = d.createCopy() + # Make a subdir so we guard against WORKDIR==S + workdir = os.path.join(tempdir, 'workdir') + crd.setVar('WORKDIR', workdir) + if not crd.getVar('S').startswith(workdir): + # Usually a shared workdir recipe (kernel, gcc) + # Try to set a reasonable default + if bb.data.inherits_class('kernel', d): + crd.setVar('S', '${WORKDIR}/source') + else: + crd.setVar('S', '${WORKDIR}/%s' % os.path.basename(d.getVar('S'))) + if bb.data.inherits_class('kernel', d): + # We don't want to move the source to STAGING_KERNEL_DIR here + crd.setVar('STAGING_KERNEL_DIR', '${S}') + + is_kernel_yocto = bb.data.inherits_class('kernel-yocto', d) + if not is_kernel_yocto: + crd.setVar('PATCHTOOL', 'git') + crd.setVar('PATCH_COMMIT_FUNCTIONS', '1') + + # Apply our changes to the datastore to the server's datastore + for key in crd.localkeys(): + tinfoil.config_data.setVar('%s_pn-%s' % (key, pn), crd.getVar(key, False)) + + tinfoil.config_data.setVar('STAMPS_DIR', os.path.join(tempdir, 'stamps')) + tinfoil.config_data.setVar('T', os.path.join(tempdir, 'temp')) + tinfoil.config_data.setVar('BUILDCFG_FUNCS', '') + tinfoil.config_data.setVar('BUILDCFG_HEADER', '') + tinfoil.config_data.setVar('BB_HASH_IGNORE_MISMATCH', '1') + + tinfoil.set_event_mask(['bb.event.BuildStarted', + 'bb.event.BuildCompleted', + 'logging.LogRecord', + 'bb.command.CommandCompleted', + 'bb.command.CommandFailed', + 'bb.build.TaskStarted', + 'bb.build.TaskSucceeded', + 'bb.build.TaskFailed', + 'bb.build.TaskFailedSilent']) + + def runtask(target, task): + if tinfoil.build_file(target, task): + while True: + event = tinfoil.wait_event(0.25) + if event: + if isinstance(event, bb.command.CommandCompleted): + break + elif isinstance(event, bb.command.CommandFailed): + raise DevtoolError('Task do_%s failed: %s' % (task, event.error)) + elif isinstance(event, bb.build.TaskFailed): + raise DevtoolError('Task do_%s failed' % task) + elif isinstance(event, bb.build.TaskStarted): + logger.info('Executing %s...' % event._task) + elif isinstance(event, logging.LogRecord): + if event.levelno <= logging.INFO: + continue + logger.handle(event) + + # we need virtual:native:/path/to/recipe if it's a BBCLASSEXTEND + fn = tinfoil.get_recipe_file(pn) + runtask(fn, 'unpack') + + if bb.data.inherits_class('kernel-yocto', d): + # Extra step for kernel to populate the source directory + runtask(fn, 'kernel_checkout') + + srcsubdir = crd.getVar('S') + + # Move local source files into separate subdir + recipe_patches = [os.path.basename(patch) for patch in + oe.recipeutils.get_recipe_patches(crd)] + local_files = oe.recipeutils.get_recipe_local_files(crd) + + # Ignore local files with subdir={BP} + srcabspath = os.path.abspath(srcsubdir) + local_files = [fname for fname in local_files if + os.path.exists(os.path.join(workdir, fname)) and + (srcabspath == workdir or not + os.path.join(workdir, fname).startswith(srcabspath + + os.sep))] + if local_files: + for fname in local_files: + _move_file(os.path.join(workdir, fname), + os.path.join(tempdir, 'oe-local-files', fname)) + with open(os.path.join(tempdir, 'oe-local-files', '.gitignore'), + 'w') as f: + f.write('# Ignore local files, by default. Remove this file ' + 'if you want to commit the directory to Git\n*\n') + + if srcsubdir == workdir: + # Find non-patch non-local sources that were "unpacked" to srctree + # directory + src_files = [fname for fname in _ls_tree(workdir) if + os.path.basename(fname) not in recipe_patches] + # Force separate S so that patch files can be left out from srctree + srcsubdir = tempfile.mkdtemp(dir=workdir) + tinfoil.config_data.setVar('S_task-patch', srcsubdir) + # Move source files to S + for path in src_files: + _move_file(os.path.join(workdir, path), + os.path.join(srcsubdir, path)) + elif os.path.dirname(srcsubdir) != workdir: + # Handle if S is set to a subdirectory of the source + srcsubdir = os.path.join(workdir, os.path.relpath(srcsubdir, workdir).split(os.sep)[0]) + + scriptutils.git_convert_standalone_clone(srcsubdir) + + # Make sure that srcsubdir exists + bb.utils.mkdirhier(srcsubdir) + if not os.path.exists(srcsubdir) or not os.listdir(srcsubdir): + logger.warning("no source unpacked to S, either the %s recipe " + "doesn't use any source or the correct source " + "directory could not be determined" % pn) + + setup_git_repo(srcsubdir, crd.getVar('PV'), devbranch, d=d) + + (stdout, _) = bb.process.run('git rev-parse HEAD', cwd=srcsubdir) + initial_rev = stdout.rstrip() + + logger.info('Patching...') + runtask(fn, 'patch') + + bb.process.run('git tag -f devtool-patched', cwd=srcsubdir) + + kconfig = None + if bb.data.inherits_class('kernel-yocto', d): + # Store generate and store kernel config + logger.info('Generating kernel config') + runtask(fn, 'configure') + kconfig = os.path.join(crd.getVar('B'), '.config') + + + tempdir_localdir = os.path.join(tempdir, 'oe-local-files') + srctree_localdir = os.path.join(srctree, 'oe-local-files') + + if sync: + bb.process.run('git fetch file://' + srcsubdir + ' ' + devbranch + ':' + devbranch, cwd=srctree) + + # Move oe-local-files directory to srctree + # As the oe-local-files is not part of the constructed git tree, + # remove them directly during the synchrounizating might surprise + # the users. Instead, we move it to oe-local-files.bak and remind + # user in the log message. + if os.path.exists(srctree_localdir + '.bak'): + shutil.rmtree(srctree_localdir, srctree_localdir + '.bak') + + if os.path.exists(srctree_localdir): + logger.info('Backing up current local file directory %s' % srctree_localdir) + shutil.move(srctree_localdir, srctree_localdir + '.bak') + + if os.path.exists(tempdir_localdir): + logger.info('Syncing local source files to srctree...') + shutil.copytree(tempdir_localdir, srctree_localdir) + else: + # Move oe-local-files directory to srctree + if os.path.exists(tempdir_localdir): + logger.info('Adding local source files to srctree...') + shutil.move(tempdir_localdir, srcsubdir) + + shutil.move(srcsubdir, srctree) + + if os.path.abspath(d.getVar('S')) == os.path.abspath(d.getVar('WORKDIR')): + # If recipe extracts to ${WORKDIR}, symlink the files into the srctree + # (otherwise the recipe won't build as expected) + local_files_dir = os.path.join(srctree, 'oe-local-files') + addfiles = [] + for root, _, files in os.walk(local_files_dir): + relpth = os.path.relpath(root, local_files_dir) + if relpth != '.': + bb.utils.mkdirhier(os.path.join(srctree, relpth)) + for fn in files: + if fn == '.gitignore': + continue + destpth = os.path.join(srctree, relpth, fn) + if os.path.exists(destpth): + os.unlink(destpth) + os.symlink('oe-local-files/%s' % fn, destpth) + addfiles.append(os.path.join(relpth, fn)) + if addfiles: + bb.process.run('git add %s' % ' '.join(addfiles), cwd=srctree) + useroptions = [] + oe.patch.GitApplyTree.gitCommandUserOptions(useroptions, d=d) + bb.process.run('git %s commit -a -m "Committing local file symlinks\n\n%s"' % (' '.join(useroptions), oe.patch.GitApplyTree.ignore_commit_prefix), cwd=srctree) + + if kconfig: + logger.info('Copying kernel config to srctree') + shutil.copy2(kconfig, srctree) + + finally: + if keep_temp: + logger.info('Preserving temporary directory %s' % tempdir) + else: + shutil.rmtree(tempdir) + return initial_rev + +def _add_md5(config, recipename, filename): + """Record checksum of a file (or recursively for a directory) to the md5-file of the workspace""" + import bb.utils + + def addfile(fn): + md5 = bb.utils.md5_file(fn) + with open(os.path.join(config.workspace_path, '.devtool_md5'), 'a') as f: + f.write('%s|%s|%s\n' % (recipename, os.path.relpath(fn, config.workspace_path), md5)) + + if os.path.isdir(filename): + for root, _, files in os.walk(filename): + for f in files: + addfile(os.path.join(root, f)) + else: + addfile(filename) + +def _check_preserve(config, recipename): + """Check if a file was manually changed and needs to be saved in 'attic' + directory""" + import bb.utils + origfile = os.path.join(config.workspace_path, '.devtool_md5') + newfile = os.path.join(config.workspace_path, '.devtool_md5_new') + preservepath = os.path.join(config.workspace_path, 'attic', recipename) + with open(origfile, 'r') as f: + with open(newfile, 'w') as tf: + for line in f.readlines(): + splitline = line.rstrip().split('|') + if splitline[0] == recipename: + removefile = os.path.join(config.workspace_path, splitline[1]) + try: + md5 = bb.utils.md5_file(removefile) + except IOError as err: + if err.errno == 2: + # File no longer exists, skip it + continue + else: + raise + if splitline[2] != md5: + bb.utils.mkdirhier(preservepath) + preservefile = os.path.basename(removefile) + logger.warn('File %s modified since it was written, preserving in %s' % (preservefile, preservepath)) + shutil.move(removefile, os.path.join(preservepath, preservefile)) + else: + os.remove(removefile) + else: + tf.write(line) + os.rename(newfile, origfile) + +def modify(args, config, basepath, workspace): + """Entry point for the devtool 'modify' subcommand""" + import bb + import oe.recipeutils + + if args.recipename in workspace: + raise DevtoolError("recipe %s is already in your workspace" % + args.recipename) + + tinfoil = setup_tinfoil(basepath=basepath) + try: + rd = parse_recipe(config, tinfoil, args.recipename, True) + if not rd: + return 1 + + pn = rd.getVar('PN') + if pn != args.recipename: + logger.info('Mapping %s to %s' % (args.recipename, pn)) + if pn in workspace: + raise DevtoolError("recipe %s is already in your workspace" % + pn) + + if args.srctree: + srctree = os.path.abspath(args.srctree) + else: + srctree = get_default_srctree(config, pn) + + if args.no_extract and not os.path.isdir(srctree): + raise DevtoolError("--no-extract specified and source path %s does " + "not exist or is not a directory" % + srctree) + if not args.no_extract: + tinfoil = _prep_extract_operation(config, basepath, pn, tinfoil) + if not tinfoil: + # Error already shown + return 1 + # We need to re-parse because tinfoil may have been re-initialised + rd = parse_recipe(config, tinfoil, args.recipename, True) + + recipefile = rd.getVar('FILE') + appendfile = recipe_to_append(recipefile, config, args.wildcard) + if os.path.exists(appendfile): + raise DevtoolError("Another variant of recipe %s is already in your " + "workspace (only one variant of a recipe can " + "currently be worked on at once)" + % pn) + + _check_compatible_recipe(pn, rd) + + initial_rev = None + commits = [] + if not args.no_extract: + initial_rev = _extract_source(srctree, args.keep_temp, args.branch, False, rd, tinfoil) + if not initial_rev: + return 1 + logger.info('Source tree extracted to %s' % srctree) + # Get list of commits since this revision + (stdout, _) = bb.process.run('git rev-list --reverse %s..HEAD' % initial_rev, cwd=srctree) + commits = stdout.split() + else: + if os.path.exists(os.path.join(srctree, '.git')): + # Check if it's a tree previously extracted by us + try: + (stdout, _) = bb.process.run('git branch --contains devtool-base', cwd=srctree) + except bb.process.ExecutionError: + stdout = '' + for line in stdout.splitlines(): + if line.startswith('*'): + (stdout, _) = bb.process.run('git rev-parse devtool-base', cwd=srctree) + initial_rev = stdout.rstrip() + if not initial_rev: + # Otherwise, just grab the head revision + (stdout, _) = bb.process.run('git rev-parse HEAD', cwd=srctree) + initial_rev = stdout.rstrip() + + # Check that recipe isn't using a shared workdir + s = os.path.abspath(rd.getVar('S')) + workdir = os.path.abspath(rd.getVar('WORKDIR')) + if s.startswith(workdir) and s != workdir and os.path.dirname(s) != workdir: + # Handle if S is set to a subdirectory of the source + srcsubdir = os.path.relpath(s, workdir).split(os.sep, 1)[1] + srctree = os.path.join(srctree, srcsubdir) + + bb.utils.mkdirhier(os.path.dirname(appendfile)) + with open(appendfile, 'w') as f: + f.write('FILESEXTRAPATHS_prepend := "${THISDIR}/${PN}:"\n') + # Local files can be modified/tracked in separate subdir under srctree + # Mostly useful for packages with S != WORKDIR + f.write('FILESPATH_prepend := "%s:"\n' % + os.path.join(srctree, 'oe-local-files')) + + f.write('\ninherit externalsrc\n') + f.write('# NOTE: We use pn- overrides here to avoid affecting multiple variants in the case where the recipe uses BBCLASSEXTEND\n') + f.write('EXTERNALSRC_pn-%s = "%s"\n' % (pn, srctree)) + + b_is_s = use_external_build(args.same_dir, args.no_same_dir, rd) + if b_is_s: + f.write('EXTERNALSRC_BUILD_pn-%s = "%s"\n' % (pn, srctree)) + + if bb.data.inherits_class('kernel', rd): + f.write('SRCTREECOVEREDTASKS = "do_validate_branches do_kernel_checkout ' + 'do_fetch do_unpack do_patch do_kernel_configme do_kernel_configcheck"\n') + f.write('\ndo_configure_append() {\n' + ' cp ${B}/.config ${S}/.config.baseline\n' + ' ln -sfT ${B}/.config ${S}/.config.new\n' + '}\n') + if initial_rev: + f.write('\n# initial_rev: %s\n' % initial_rev) + for commit in commits: + f.write('# commit: %s\n' % commit) + + _add_md5(config, pn, appendfile) + + logger.info('Recipe %s now set up to build from %s' % (pn, srctree)) + + finally: + tinfoil.shutdown() + + return 0 + + +def rename(args, config, basepath, workspace): + """Entry point for the devtool 'rename' subcommand""" + import bb + import oe.recipeutils + + check_workspace_recipe(workspace, args.recipename) + + if not (args.newname or args.version): + raise DevtoolError('You must specify a new name, a version with -V/--version, or both') + + recipefile = workspace[args.recipename]['recipefile'] + if not recipefile: + raise DevtoolError('devtool rename can only be used where the recipe file itself is in the workspace (e.g. after devtool add)') + + if args.newname and args.newname != args.recipename: + reason = oe.recipeutils.validate_pn(args.newname) + if reason: + raise DevtoolError(reason) + newname = args.newname + else: + newname = args.recipename + + append = workspace[args.recipename]['bbappend'] + appendfn = os.path.splitext(os.path.basename(append))[0] + splitfn = appendfn.split('_') + if len(splitfn) > 1: + origfnver = appendfn.split('_')[1] + else: + origfnver = '' + + recipefilemd5 = None + tinfoil = setup_tinfoil(basepath=basepath, tracking=True) + try: + rd = parse_recipe(config, tinfoil, args.recipename, True) + if not rd: + return 1 + + bp = rd.getVar('BP') + bpn = rd.getVar('BPN') + if newname != args.recipename: + localdata = rd.createCopy() + localdata.setVar('PN', newname) + newbpn = localdata.getVar('BPN') + else: + newbpn = bpn + s = rd.getVar('S', False) + src_uri = rd.getVar('SRC_URI', False) + pv = rd.getVar('PV') + + # Correct variable values that refer to the upstream source - these + # values must stay the same, so if the name/version are changing then + # we need to fix them up + new_s = s + new_src_uri = src_uri + if newbpn != bpn: + # ${PN} here is technically almost always incorrect, but people do use it + new_s = new_s.replace('${BPN}', bpn) + new_s = new_s.replace('${PN}', bpn) + new_s = new_s.replace('${BP}', '%s-${PV}' % bpn) + new_src_uri = new_src_uri.replace('${BPN}', bpn) + new_src_uri = new_src_uri.replace('${PN}', bpn) + new_src_uri = new_src_uri.replace('${BP}', '%s-${PV}' % bpn) + if args.version and origfnver == pv: + new_s = new_s.replace('${PV}', pv) + new_s = new_s.replace('${BP}', '${BPN}-%s' % pv) + new_src_uri = new_src_uri.replace('${PV}', pv) + new_src_uri = new_src_uri.replace('${BP}', '${BPN}-%s' % pv) + patchfields = {} + if new_s != s: + patchfields['S'] = new_s + if new_src_uri != src_uri: + patchfields['SRC_URI'] = new_src_uri + if patchfields: + recipefilemd5 = bb.utils.md5_file(recipefile) + oe.recipeutils.patch_recipe(rd, recipefile, patchfields) + newrecipefilemd5 = bb.utils.md5_file(recipefile) + finally: + tinfoil.shutdown() + + if args.version: + newver = args.version + else: + newver = origfnver + + if newver: + newappend = '%s_%s.bbappend' % (newname, newver) + newfile = '%s_%s.bb' % (newname, newver) + else: + newappend = '%s.bbappend' % newname + newfile = '%s.bb' % newname + + oldrecipedir = os.path.dirname(recipefile) + newrecipedir = os.path.join(config.workspace_path, 'recipes', newname) + if oldrecipedir != newrecipedir: + bb.utils.mkdirhier(newrecipedir) + + newappend = os.path.join(os.path.dirname(append), newappend) + newfile = os.path.join(newrecipedir, newfile) + + # Rename bbappend + logger.info('Renaming %s to %s' % (append, newappend)) + os.rename(append, newappend) + # Rename recipe file + logger.info('Renaming %s to %s' % (recipefile, newfile)) + os.rename(recipefile, newfile) + + # Rename source tree if it's the default path + appendmd5 = None + if not args.no_srctree: + srctree = workspace[args.recipename]['srctree'] + if os.path.abspath(srctree) == os.path.join(config.workspace_path, 'sources', args.recipename): + newsrctree = os.path.join(config.workspace_path, 'sources', newname) + logger.info('Renaming %s to %s' % (srctree, newsrctree)) + shutil.move(srctree, newsrctree) + # Correct any references (basically EXTERNALSRC*) in the .bbappend + appendmd5 = bb.utils.md5_file(newappend) + appendlines = [] + with open(newappend, 'r') as f: + for line in f: + appendlines.append(line) + with open(newappend, 'w') as f: + for line in appendlines: + if srctree in line: + line = line.replace(srctree, newsrctree) + f.write(line) + newappendmd5 = bb.utils.md5_file(newappend) + + bpndir = None + newbpndir = None + if newbpn != bpn: + bpndir = os.path.join(oldrecipedir, bpn) + if os.path.exists(bpndir): + newbpndir = os.path.join(newrecipedir, newbpn) + logger.info('Renaming %s to %s' % (bpndir, newbpndir)) + shutil.move(bpndir, newbpndir) + + bpdir = None + newbpdir = None + if newver != origfnver or newbpn != bpn: + bpdir = os.path.join(oldrecipedir, bp) + if os.path.exists(bpdir): + newbpdir = os.path.join(newrecipedir, '%s-%s' % (newbpn, newver)) + logger.info('Renaming %s to %s' % (bpdir, newbpdir)) + shutil.move(bpdir, newbpdir) + + if oldrecipedir != newrecipedir: + # Move any stray files and delete the old recipe directory + for entry in os.listdir(oldrecipedir): + oldpath = os.path.join(oldrecipedir, entry) + newpath = os.path.join(newrecipedir, entry) + logger.info('Renaming %s to %s' % (oldpath, newpath)) + shutil.move(oldpath, newpath) + os.rmdir(oldrecipedir) + + # Now take care of entries in .devtool_md5 + md5entries = [] + with open(os.path.join(config.workspace_path, '.devtool_md5'), 'r') as f: + for line in f: + md5entries.append(line) + + if bpndir and newbpndir: + relbpndir = os.path.relpath(bpndir, config.workspace_path) + '/' + else: + relbpndir = None + if bpdir and newbpdir: + relbpdir = os.path.relpath(bpdir, config.workspace_path) + '/' + else: + relbpdir = None + + with open(os.path.join(config.workspace_path, '.devtool_md5'), 'w') as f: + for entry in md5entries: + splitentry = entry.rstrip().split('|') + if len(splitentry) > 2: + if splitentry[0] == args.recipename: + splitentry[0] = newname + if splitentry[1] == os.path.relpath(append, config.workspace_path): + splitentry[1] = os.path.relpath(newappend, config.workspace_path) + if appendmd5 and splitentry[2] == appendmd5: + splitentry[2] = newappendmd5 + elif splitentry[1] == os.path.relpath(recipefile, config.workspace_path): + splitentry[1] = os.path.relpath(newfile, config.workspace_path) + if recipefilemd5 and splitentry[2] == recipefilemd5: + splitentry[2] = newrecipefilemd5 + elif relbpndir and splitentry[1].startswith(relbpndir): + splitentry[1] = os.path.relpath(os.path.join(newbpndir, splitentry[1][len(relbpndir):]), config.workspace_path) + elif relbpdir and splitentry[1].startswith(relbpdir): + splitentry[1] = os.path.relpath(os.path.join(newbpdir, splitentry[1][len(relbpdir):]), config.workspace_path) + entry = '|'.join(splitentry) + '\n' + f.write(entry) + return 0 + + +def _get_patchset_revs(srctree, recipe_path, initial_rev=None): + """Get initial and update rev of a recipe. These are the start point of the + whole patchset and start point for the patches to be re-generated/updated. + """ + import bb + + # Parse initial rev from recipe if not specified + commits = [] + with open(recipe_path, 'r') as f: + for line in f: + if line.startswith('# initial_rev:'): + if not initial_rev: + initial_rev = line.split(':')[-1].strip() + elif line.startswith('# commit:'): + commits.append(line.split(':')[-1].strip()) + + update_rev = initial_rev + changed_revs = None + if initial_rev: + # Find first actually changed revision + stdout, _ = bb.process.run('git rev-list --reverse %s..HEAD' % + initial_rev, cwd=srctree) + newcommits = stdout.split() + for i in range(min(len(commits), len(newcommits))): + if newcommits[i] == commits[i]: + update_rev = commits[i] + + try: + stdout, _ = bb.process.run('git cherry devtool-patched', + cwd=srctree) + except bb.process.ExecutionError as err: + stdout = None + + if stdout is not None: + changed_revs = [] + for line in stdout.splitlines(): + if line.startswith('+ '): + rev = line.split()[1] + if rev in newcommits: + changed_revs.append(rev) + + return initial_rev, update_rev, changed_revs + +def _remove_file_entries(srcuri, filelist): + """Remove file:// entries from SRC_URI""" + remaining = filelist[:] + entries = [] + for fname in filelist: + basename = os.path.basename(fname) + for i in range(len(srcuri)): + if (srcuri[i].startswith('file://') and + os.path.basename(srcuri[i].split(';')[0]) == basename): + entries.append(srcuri[i]) + remaining.remove(fname) + srcuri.pop(i) + break + return entries, remaining + +def _replace_srcuri_entry(srcuri, filename, newentry): + """Replace entry corresponding to specified file with a new entry""" + basename = os.path.basename(filename) + for i in range(len(srcuri)): + if os.path.basename(srcuri[i].split(';')[0]) == basename: + srcuri.pop(i) + srcuri.insert(i, newentry) + break + +def _remove_source_files(append, files, destpath): + """Unlink existing patch files""" + for path in files: + if append: + if not destpath: + raise Exception('destpath should be set here') + path = os.path.join(destpath, os.path.basename(path)) + + if os.path.exists(path): + logger.info('Removing file %s' % path) + # FIXME "git rm" here would be nice if the file in question is + # tracked + # FIXME there's a chance that this file is referred to by + # another recipe, in which case deleting wouldn't be the + # right thing to do + os.remove(path) + # Remove directory if empty + try: + os.rmdir(os.path.dirname(path)) + except OSError as ose: + if ose.errno != errno.ENOTEMPTY: + raise + + +def _export_patches(srctree, rd, start_rev, destdir, changed_revs=None): + """Export patches from srctree to given location. + Returns three-tuple of dicts: + 1. updated - patches that already exist in SRCURI + 2. added - new patches that don't exist in SRCURI + 3 removed - patches that exist in SRCURI but not in exported patches + In each dict the key is the 'basepath' of the URI and value is the + absolute path to the existing file in recipe space (if any). + """ + import oe.recipeutils + from oe.patch import GitApplyTree + updated = OrderedDict() + added = OrderedDict() + seqpatch_re = re.compile('^([0-9]{4}-)?(.+)') + + existing_patches = dict((os.path.basename(path), path) for path in + oe.recipeutils.get_recipe_patches(rd)) + + # Generate patches from Git, exclude local files directory + patch_pathspec = _git_exclude_path(srctree, 'oe-local-files') + GitApplyTree.extractPatches(srctree, start_rev, destdir, patch_pathspec) + + new_patches = sorted(os.listdir(destdir)) + for new_patch in new_patches: + # Strip numbering from patch names. If it's a git sequence named patch, + # the numbers might not match up since we are starting from a different + # revision This does assume that people are using unique shortlog + # values, but they ought to be anyway... + new_basename = seqpatch_re.match(new_patch).group(2) + match_name = None + for old_patch in existing_patches: + old_basename = seqpatch_re.match(old_patch).group(2) + old_basename_splitext = os.path.splitext(old_basename) + if old_basename.endswith(('.gz', '.bz2', '.Z')) and old_basename_splitext[0] == new_basename: + old_patch_noext = os.path.splitext(old_patch)[0] + match_name = old_patch_noext + break + elif new_basename == old_basename: + match_name = old_patch + break + if match_name: + # Rename patch files + if new_patch != match_name: + os.rename(os.path.join(destdir, new_patch), + os.path.join(destdir, match_name)) + # Need to pop it off the list now before checking changed_revs + oldpath = existing_patches.pop(old_patch) + if changed_revs is not None: + # Avoid updating patches that have not actually changed + with open(os.path.join(destdir, match_name), 'r') as f: + firstlineitems = f.readline().split() + # Looking for "From <hash>" line + if len(firstlineitems) > 1 and len(firstlineitems[1]) == 40: + if not firstlineitems[1] in changed_revs: + continue + # Recompress if necessary + if oldpath.endswith(('.gz', '.Z')): + bb.process.run(['gzip', match_name], cwd=destdir) + if oldpath.endswith('.gz'): + match_name += '.gz' + else: + match_name += '.Z' + elif oldpath.endswith('.bz2'): + bb.process.run(['bzip2', match_name], cwd=destdir) + match_name += '.bz2' + updated[match_name] = oldpath + else: + added[new_patch] = None + return (updated, added, existing_patches) + + +def _create_kconfig_diff(srctree, rd, outfile): + """Create a kconfig fragment""" + # Only update config fragment if both config files exist + orig_config = os.path.join(srctree, '.config.baseline') + new_config = os.path.join(srctree, '.config.new') + if os.path.exists(orig_config) and os.path.exists(new_config): + cmd = ['diff', '--new-line-format=%L', '--old-line-format=', + '--unchanged-line-format=', orig_config, new_config] + pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE, + stderr=subprocess.PIPE) + stdout, stderr = pipe.communicate() + if pipe.returncode == 1: + logger.info("Updating config fragment %s" % outfile) + with open(outfile, 'wb') as fobj: + fobj.write(stdout) + elif pipe.returncode == 0: + logger.info("Would remove config fragment %s" % outfile) + if os.path.exists(outfile): + # Remove fragment file in case of empty diff + logger.info("Removing config fragment %s" % outfile) + os.unlink(outfile) + else: + raise bb.process.ExecutionError(cmd, pipe.returncode, stdout, stderr) + return True + return False + + +def _export_local_files(srctree, rd, destdir): + """Copy local files from srctree to given location. + Returns three-tuple of dicts: + 1. updated - files that already exist in SRCURI + 2. added - new files files that don't exist in SRCURI + 3 removed - files that exist in SRCURI but not in exported files + In each dict the key is the 'basepath' of the URI and value is the + absolute path to the existing file in recipe space (if any). + """ + import oe.recipeutils + + # Find out local files (SRC_URI files that exist in the "recipe space"). + # Local files that reside in srctree are not included in patch generation. + # Instead they are directly copied over the original source files (in + # recipe space). + existing_files = oe.recipeutils.get_recipe_local_files(rd) + new_set = None + updated = OrderedDict() + added = OrderedDict() + removed = OrderedDict() + local_files_dir = os.path.join(srctree, 'oe-local-files') + git_files = _git_ls_tree(srctree) + if 'oe-local-files' in git_files: + # If tracked by Git, take the files from srctree HEAD. First get + # the tree object of the directory + tmp_index = os.path.join(srctree, '.git', 'index.tmp.devtool') + tree = git_files['oe-local-files'][2] + bb.process.run(['git', 'checkout', tree, '--', '.'], cwd=srctree, + env=dict(os.environ, GIT_WORK_TREE=destdir, + GIT_INDEX_FILE=tmp_index)) + new_set = list(_git_ls_tree(srctree, tree, True).keys()) + elif os.path.isdir(local_files_dir): + # If not tracked by Git, just copy from working copy + new_set = _ls_tree(os.path.join(srctree, 'oe-local-files')) + bb.process.run(['cp', '-ax', + os.path.join(srctree, 'oe-local-files', '.'), destdir]) + else: + new_set = [] + + # Special handling for kernel config + if bb.data.inherits_class('kernel-yocto', rd): + fragment_fn = 'devtool-fragment.cfg' + fragment_path = os.path.join(destdir, fragment_fn) + if _create_kconfig_diff(srctree, rd, fragment_path): + if os.path.exists(fragment_path): + if fragment_fn not in new_set: + new_set.append(fragment_fn) + # Copy fragment to local-files + if os.path.isdir(local_files_dir): + shutil.copy2(fragment_path, local_files_dir) + else: + if fragment_fn in new_set: + new_set.remove(fragment_fn) + # Remove fragment from local-files + if os.path.exists(os.path.join(local_files_dir, fragment_fn)): + os.unlink(os.path.join(local_files_dir, fragment_fn)) + + if new_set is not None: + for fname in new_set: + if fname in existing_files: + origpath = existing_files.pop(fname) + workpath = os.path.join(local_files_dir, fname) + if not filecmp.cmp(origpath, workpath): + updated[fname] = origpath + elif fname != '.gitignore': + added[fname] = None + + workdir = rd.getVar('WORKDIR') + s = rd.getVar('S') + if not s.endswith(os.sep): + s += os.sep + + if workdir != s: + # Handle files where subdir= was specified + for fname in list(existing_files.keys()): + # FIXME handle both subdir starting with BP and not? + fworkpath = os.path.join(workdir, fname) + if fworkpath.startswith(s): + fpath = os.path.join(srctree, os.path.relpath(fworkpath, s)) + if os.path.exists(fpath): + origpath = existing_files.pop(fname) + if not filecmp.cmp(origpath, fpath): + updated[fpath] = origpath + + removed = existing_files + return (updated, added, removed) + + +def _determine_files_dir(rd): + """Determine the appropriate files directory for a recipe""" + recipedir = rd.getVar('FILE_DIRNAME') + for entry in rd.getVar('FILESPATH').split(':'): + relpth = os.path.relpath(entry, recipedir) + if not os.sep in relpth: + # One (or zero) levels below only, so we don't put anything in machine-specific directories + if os.path.isdir(entry): + return entry + return os.path.join(recipedir, rd.getVar('BPN')) + + +def _update_recipe_srcrev(srctree, rd, appendlayerdir, wildcard_version, no_remove): + """Implement the 'srcrev' mode of update-recipe""" + import bb + import oe.recipeutils + + recipefile = rd.getVar('FILE') + logger.info('Updating SRCREV in recipe %s' % os.path.basename(recipefile)) + + # Get HEAD revision + try: + stdout, _ = bb.process.run('git rev-parse HEAD', cwd=srctree) + except bb.process.ExecutionError as err: + raise DevtoolError('Failed to get HEAD revision in %s: %s' % + (srctree, err)) + srcrev = stdout.strip() + if len(srcrev) != 40: + raise DevtoolError('Invalid hash returned by git: %s' % stdout) + + destpath = None + remove_files = [] + patchfields = {} + patchfields['SRCREV'] = srcrev + orig_src_uri = rd.getVar('SRC_URI', False) or '' + srcuri = orig_src_uri.split() + tempdir = tempfile.mkdtemp(prefix='devtool') + update_srcuri = False + try: + local_files_dir = tempfile.mkdtemp(dir=tempdir) + upd_f, new_f, del_f = _export_local_files(srctree, rd, local_files_dir) + if not no_remove: + # Find list of existing patches in recipe file + patches_dir = tempfile.mkdtemp(dir=tempdir) + old_srcrev = (rd.getVar('SRCREV', False) or '') + upd_p, new_p, del_p = _export_patches(srctree, rd, old_srcrev, + patches_dir) + + # Remove deleted local files and "overlapping" patches + remove_files = list(del_f.values()) + list(upd_p.values()) + if remove_files: + removedentries = _remove_file_entries(srcuri, remove_files)[0] + update_srcuri = True + + if appendlayerdir: + files = dict((os.path.join(local_files_dir, key), val) for + key, val in list(upd_f.items()) + list(new_f.items())) + removevalues = {} + if update_srcuri: + removevalues = {'SRC_URI': removedentries} + patchfields['SRC_URI'] = '\\\n '.join(srcuri) + _, destpath = oe.recipeutils.bbappend_recipe( + rd, appendlayerdir, files, wildcardver=wildcard_version, + extralines=patchfields, removevalues=removevalues) + else: + files_dir = _determine_files_dir(rd) + for basepath, path in upd_f.items(): + logger.info('Updating file %s' % basepath) + if os.path.isabs(basepath): + # Original file (probably with subdir pointing inside source tree) + # so we do not want to move it, just copy + _copy_file(basepath, path) + else: + _move_file(os.path.join(local_files_dir, basepath), path) + update_srcuri= True + for basepath, path in new_f.items(): + logger.info('Adding new file %s' % basepath) + _move_file(os.path.join(local_files_dir, basepath), + os.path.join(files_dir, basepath)) + srcuri.append('file://%s' % basepath) + update_srcuri = True + if update_srcuri: + patchfields['SRC_URI'] = ' '.join(srcuri) + oe.recipeutils.patch_recipe(rd, recipefile, patchfields) + finally: + shutil.rmtree(tempdir) + if not 'git://' in orig_src_uri: + logger.info('You will need to update SRC_URI within the recipe to ' + 'point to a git repository where you have pushed your ' + 'changes') + + _remove_source_files(appendlayerdir, remove_files, destpath) + return True + +def _update_recipe_patch(recipename, workspace, srctree, rd, appendlayerdir, wildcard_version, no_remove, initial_rev): + """Implement the 'patch' mode of update-recipe""" + import bb + import oe.recipeutils + + recipefile = rd.getVar('FILE') + append = workspace[recipename]['bbappend'] + if not os.path.exists(append): + raise DevtoolError('unable to find workspace bbappend for recipe %s' % + recipename) + + initial_rev, update_rev, changed_revs = _get_patchset_revs(srctree, append, initial_rev) + if not initial_rev: + raise DevtoolError('Unable to find initial revision - please specify ' + 'it with --initial-rev') + + dl_dir = rd.getVar('DL_DIR') + if not dl_dir.endswith('/'): + dl_dir += '/' + + tempdir = tempfile.mkdtemp(prefix='devtool') + try: + local_files_dir = tempfile.mkdtemp(dir=tempdir) + upd_f, new_f, del_f = _export_local_files(srctree, rd, local_files_dir) + + remove_files = [] + if not no_remove: + # Get all patches from source tree and check if any should be removed + all_patches_dir = tempfile.mkdtemp(dir=tempdir) + upd_p, new_p, del_p = _export_patches(srctree, rd, initial_rev, + all_patches_dir) + # Remove deleted local files and patches + remove_files = list(del_f.values()) + list(del_p.values()) + + # Get updated patches from source tree + patches_dir = tempfile.mkdtemp(dir=tempdir) + upd_p, new_p, del_p = _export_patches(srctree, rd, update_rev, + patches_dir, changed_revs) + updatefiles = False + updaterecipe = False + destpath = None + srcuri = (rd.getVar('SRC_URI', False) or '').split() + if appendlayerdir: + files = dict((os.path.join(local_files_dir, key), val) for + key, val in list(upd_f.items()) + list(new_f.items())) + files.update(dict((os.path.join(patches_dir, key), val) for + key, val in list(upd_p.items()) + list(new_p.items()))) + if files or remove_files: + removevalues = None + if remove_files: + removedentries, remaining = _remove_file_entries( + srcuri, remove_files) + if removedentries or remaining: + remaining = ['file://' + os.path.basename(item) for + item in remaining] + removevalues = {'SRC_URI': removedentries + remaining} + _, destpath = oe.recipeutils.bbappend_recipe( + rd, appendlayerdir, files, + wildcardver=wildcard_version, + removevalues=removevalues) + else: + logger.info('No patches or local source files needed updating') + else: + # Update existing files + files_dir = _determine_files_dir(rd) + for basepath, path in upd_f.items(): + logger.info('Updating file %s' % basepath) + if os.path.isabs(basepath): + # Original file (probably with subdir pointing inside source tree) + # so we do not want to move it, just copy + _copy_file(basepath, path) + else: + _move_file(os.path.join(local_files_dir, basepath), path) + updatefiles = True + for basepath, path in upd_p.items(): + patchfn = os.path.join(patches_dir, basepath) + if os.path.dirname(path) + '/' == dl_dir: + # This is a a downloaded patch file - we now need to + # replace the entry in SRC_URI with our local version + logger.info('Replacing remote patch %s with updated local version' % basepath) + path = os.path.join(files_dir, basepath) + _replace_srcuri_entry(srcuri, basepath, 'file://%s' % basepath) + updaterecipe = True + else: + logger.info('Updating patch %s' % basepath) + logger.debug('Moving new patch %s to %s' % (patchfn, path)) + _move_file(patchfn, path) + updatefiles = True + # Add any new files + for basepath, path in new_f.items(): + logger.info('Adding new file %s' % basepath) + _move_file(os.path.join(local_files_dir, basepath), + os.path.join(files_dir, basepath)) + srcuri.append('file://%s' % basepath) + updaterecipe = True + for basepath, path in new_p.items(): + logger.info('Adding new patch %s' % basepath) + _move_file(os.path.join(patches_dir, basepath), + os.path.join(files_dir, basepath)) + srcuri.append('file://%s' % basepath) + updaterecipe = True + # Update recipe, if needed + if _remove_file_entries(srcuri, remove_files)[0]: + updaterecipe = True + if updaterecipe: + logger.info('Updating recipe %s' % os.path.basename(recipefile)) + oe.recipeutils.patch_recipe(rd, recipefile, + {'SRC_URI': ' '.join(srcuri)}) + elif not updatefiles: + # Neither patches nor recipe were updated + logger.info('No patches or files need updating') + return False + finally: + shutil.rmtree(tempdir) + + _remove_source_files(appendlayerdir, remove_files, destpath) + return True + +def _guess_recipe_update_mode(srctree, rdata): + """Guess the recipe update mode to use""" + src_uri = (rdata.getVar('SRC_URI', False) or '').split() + git_uris = [uri for uri in src_uri if uri.startswith('git://')] + if not git_uris: + return 'patch' + # Just use the first URI for now + uri = git_uris[0] + # Check remote branch + params = bb.fetch.decodeurl(uri)[5] + upstr_branch = params['branch'] if 'branch' in params else 'master' + # Check if current branch HEAD is found in upstream branch + stdout, _ = bb.process.run('git rev-parse HEAD', cwd=srctree) + head_rev = stdout.rstrip() + stdout, _ = bb.process.run('git branch -r --contains %s' % head_rev, + cwd=srctree) + remote_brs = [branch.strip() for branch in stdout.splitlines()] + if 'origin/' + upstr_branch in remote_brs: + return 'srcrev' + + return 'patch' + +def _update_recipe(recipename, workspace, rd, mode, appendlayerdir, wildcard_version, no_remove, initial_rev): + srctree = workspace[recipename]['srctree'] + if mode == 'auto': + mode = _guess_recipe_update_mode(srctree, rd) + + if mode == 'srcrev': + updated = _update_recipe_srcrev(srctree, rd, appendlayerdir, wildcard_version, no_remove) + elif mode == 'patch': + updated = _update_recipe_patch(recipename, workspace, srctree, rd, appendlayerdir, wildcard_version, no_remove, initial_rev) + else: + raise DevtoolError('update_recipe: invalid mode %s' % mode) + return updated + +def update_recipe(args, config, basepath, workspace): + """Entry point for the devtool 'update-recipe' subcommand""" + check_workspace_recipe(workspace, args.recipename) + + if args.append: + if not os.path.exists(args.append): + raise DevtoolError('bbappend destination layer directory "%s" ' + 'does not exist' % args.append) + if not os.path.exists(os.path.join(args.append, 'conf', 'layer.conf')): + raise DevtoolError('conf/layer.conf not found in bbappend ' + 'destination layer "%s"' % args.append) + + tinfoil = setup_tinfoil(basepath=basepath, tracking=True) + try: + + rd = parse_recipe(config, tinfoil, args.recipename, True) + if not rd: + return 1 + + updated = _update_recipe(args.recipename, workspace, rd, args.mode, args.append, args.wildcard_version, args.no_remove, args.initial_rev) + + if updated: + rf = rd.getVar('FILE') + if rf.startswith(config.workspace_path): + logger.warn('Recipe file %s has been updated but is inside the workspace - you will need to move it (and any associated files next to it) out to the desired layer before using "devtool reset" in order to keep any changes' % rf) + finally: + tinfoil.shutdown() + + return 0 + + +def status(args, config, basepath, workspace): + """Entry point for the devtool 'status' subcommand""" + if workspace: + for recipe, value in workspace.items(): + recipefile = value['recipefile'] + if recipefile: + recipestr = ' (%s)' % recipefile + else: + recipestr = '' + print("%s: %s%s" % (recipe, value['srctree'], recipestr)) + else: + logger.info('No recipes currently in your workspace - you can use "devtool modify" to work on an existing recipe or "devtool add" to add a new one') + return 0 + + +def _reset(recipes, no_clean, config, basepath, workspace): + """Reset one or more recipes""" + + if recipes and not no_clean: + if len(recipes) == 1: + logger.info('Cleaning sysroot for recipe %s...' % recipes[0]) + else: + logger.info('Cleaning sysroot for recipes %s...' % ', '.join(recipes)) + # If the recipe file itself was created in the workspace, and + # it uses BBCLASSEXTEND, then we need to also clean the other + # variants + targets = [] + for recipe in recipes: + targets.append(recipe) + recipefile = workspace[recipe]['recipefile'] + if recipefile and os.path.exists(recipefile): + targets.extend(get_bbclassextend_targets(recipefile, recipe)) + try: + exec_build_env_command(config.init_path, basepath, 'bitbake -c clean %s' % ' '.join(targets)) + except bb.process.ExecutionError as e: + raise DevtoolError('Command \'%s\' failed, output:\n%s\nIf you ' + 'wish, you may specify -n/--no-clean to ' + 'skip running this command when resetting' % + (e.command, e.stdout)) + + for pn in recipes: + _check_preserve(config, pn) + + preservepath = os.path.join(config.workspace_path, 'attic', pn, pn) + def preservedir(origdir): + if os.path.exists(origdir): + for root, dirs, files in os.walk(origdir): + for fn in files: + logger.warn('Preserving %s in %s' % (fn, preservepath)) + _move_file(os.path.join(origdir, fn), + os.path.join(preservepath, fn)) + for dn in dirs: + preservedir(os.path.join(root, dn)) + os.rmdir(origdir) + + preservedir(os.path.join(config.workspace_path, 'recipes', pn)) + # We don't automatically create this dir next to appends, but the user can + preservedir(os.path.join(config.workspace_path, 'appends', pn)) + + srctree = workspace[pn]['srctree'] + if os.path.isdir(srctree): + if os.listdir(srctree): + # We don't want to risk wiping out any work in progress + logger.info('Leaving source tree %s as-is; if you no ' + 'longer need it then please delete it manually' + % srctree) + else: + # This is unlikely, but if it's empty we can just remove it + os.rmdir(srctree) + + +def reset(args, config, basepath, workspace): + """Entry point for the devtool 'reset' subcommand""" + import bb + if args.recipename: + if args.all: + raise DevtoolError("Recipe cannot be specified if -a/--all is used") + else: + for recipe in args.recipename: + check_workspace_recipe(workspace, recipe, checksrc=False) + elif not args.all: + raise DevtoolError("Recipe must be specified, or specify -a/--all to " + "reset all recipes") + if args.all: + recipes = list(workspace.keys()) + else: + recipes = args.recipename + + _reset(recipes, args.no_clean, config, basepath, workspace) + + return 0 + + +def _get_layer(layername, d): + """Determine the base layer path for the specified layer name/path""" + layerdirs = d.getVar('BBLAYERS').split() + layers = {os.path.basename(p): p for p in layerdirs} + # Provide some shortcuts + if layername.lower() in ['oe-core', 'openembedded-core']: + layerdir = layers.get('meta', None) + else: + layerdir = layers.get(layername, None) + if layerdir: + layerdir = os.path.abspath(layerdir) + return layerdir or layername + +def finish(args, config, basepath, workspace): + """Entry point for the devtool 'finish' subcommand""" + import bb + import oe.recipeutils + + check_workspace_recipe(workspace, args.recipename) + + no_clean = False + tinfoil = setup_tinfoil(basepath=basepath, tracking=True) + try: + rd = parse_recipe(config, tinfoil, args.recipename, True) + if not rd: + return 1 + + destlayerdir = _get_layer(args.destination, tinfoil.config_data) + origlayerdir = oe.recipeutils.find_layerdir(rd.getVar('FILE')) + + if not os.path.isdir(destlayerdir): + raise DevtoolError('Unable to find layer or directory matching "%s"' % args.destination) + + if os.path.abspath(destlayerdir) == config.workspace_path: + raise DevtoolError('"%s" specifies the workspace layer - that is not a valid destination' % args.destination) + + # If it's an upgrade, grab the original path + origpath = None + origfilelist = None + append = workspace[args.recipename]['bbappend'] + with open(append, 'r') as f: + for line in f: + if line.startswith('# original_path:'): + origpath = line.split(':')[1].strip() + elif line.startswith('# original_files:'): + origfilelist = line.split(':')[1].split() + + if origlayerdir == config.workspace_path: + # Recipe file itself is in workspace, update it there first + appendlayerdir = None + origrelpath = None + if origpath: + origlayerpath = oe.recipeutils.find_layerdir(origpath) + if origlayerpath: + origrelpath = os.path.relpath(origpath, origlayerpath) + destpath = oe.recipeutils.get_bbfile_path(rd, destlayerdir, origrelpath) + if not destpath: + raise DevtoolError("Unable to determine destination layer path - check that %s specifies an actual layer and %s/conf/layer.conf specifies BBFILES. You may also need to specify a more complete path." % (args.destination, destlayerdir)) + # Warn if the layer isn't in bblayers.conf (the code to create a bbappend will do this in other cases) + layerdirs = [os.path.abspath(layerdir) for layerdir in rd.getVar('BBLAYERS').split()] + if not os.path.abspath(destlayerdir) in layerdirs: + bb.warn('Specified destination layer is not currently enabled in bblayers.conf, so the %s recipe will now be unavailable in your current configuration until you add the layer there' % args.recipename) + + elif destlayerdir == origlayerdir: + # Same layer, update the original recipe + appendlayerdir = None + destpath = None + else: + # Create/update a bbappend in the specified layer + appendlayerdir = destlayerdir + destpath = None + + # Remove any old files in the case of an upgrade + if origpath and origfilelist and oe.recipeutils.find_layerdir(origpath) == oe.recipeutils.find_layerdir(destlayerdir): + for fn in origfilelist: + fnp = os.path.join(origpath, fn) + try: + os.remove(fnp) + except FileNotFoundError: + pass + + # Actually update the recipe / bbappend + _update_recipe(args.recipename, workspace, rd, args.mode, appendlayerdir, wildcard_version=True, no_remove=False, initial_rev=args.initial_rev) + + if origlayerdir == config.workspace_path and destpath: + # Recipe file itself is in the workspace - need to move it and any + # associated files to the specified layer + no_clean = True + logger.info('Moving recipe file to %s' % destpath) + recipedir = os.path.dirname(rd.getVar('FILE')) + for root, _, files in os.walk(recipedir): + for fn in files: + srcpath = os.path.join(root, fn) + relpth = os.path.relpath(os.path.dirname(srcpath), recipedir) + destdir = os.path.abspath(os.path.join(destpath, relpth)) + bb.utils.mkdirhier(destdir) + shutil.move(srcpath, os.path.join(destdir, fn)) + + finally: + tinfoil.shutdown() + + # Everything else has succeeded, we can now reset + _reset([args.recipename], no_clean=no_clean, config=config, basepath=basepath, workspace=workspace) + + return 0 + + +def get_default_srctree(config, recipename=''): + """Get the default srctree path""" + srctreeparent = config.get('General', 'default_source_parent_dir', config.workspace_path) + if recipename: + return os.path.join(srctreeparent, 'sources', recipename) + else: + return os.path.join(srctreeparent, 'sources') + +def register_commands(subparsers, context): + """Register devtool subcommands from this plugin""" + + defsrctree = get_default_srctree(context.config) + parser_add = subparsers.add_parser('add', help='Add a new recipe', + description='Adds a new recipe to the workspace to build a specified source tree. Can optionally fetch a remote URI and unpack it to create the source tree.', + group='starting', order=100) + parser_add.add_argument('recipename', nargs='?', help='Name for new recipe to add (just name - no version, path or extension). If not specified, will attempt to auto-detect it.') + parser_add.add_argument('srctree', nargs='?', help='Path to external source tree. If not specified, a subdirectory of %s will be used.' % defsrctree) + parser_add.add_argument('fetchuri', nargs='?', help='Fetch the specified URI and extract it to create the source tree') + group = parser_add.add_mutually_exclusive_group() + group.add_argument('--same-dir', '-s', help='Build in same directory as source', action="store_true") + group.add_argument('--no-same-dir', help='Force build in a separate build directory', action="store_true") + parser_add.add_argument('--fetch', '-f', help='Fetch the specified URI and extract it to create the source tree (deprecated - pass as positional argument instead)', metavar='URI') + parser_add.add_argument('--fetch-dev', help='For npm, also fetch devDependencies', action="store_true") + parser_add.add_argument('--version', '-V', help='Version to use within recipe (PV)') + parser_add.add_argument('--no-git', '-g', help='If fetching source, do not set up source tree as a git repository', action="store_true") + parser_add.add_argument('--autorev', '-a', help='When fetching from a git repository, set SRCREV in the recipe to a floating revision instead of fixed', action="store_true") + parser_add.add_argument('--binary', '-b', help='Treat the source tree as something that should be installed verbatim (no compilation, same directory structure). Useful with binary packages e.g. RPMs.', action='store_true') + parser_add.add_argument('--also-native', help='Also add native variant (i.e. support building recipe for the build host as well as the target machine)', action='store_true') + parser_add.add_argument('--src-subdir', help='Specify subdirectory within source tree to use', metavar='SUBDIR') + parser_add.set_defaults(func=add, fixed_setup=context.fixed_setup) + + parser_modify = subparsers.add_parser('modify', help='Modify the source for an existing recipe', + description='Sets up the build environment to modify the source for an existing recipe. The default behaviour is to extract the source being fetched by the recipe into a git tree so you can work on it; alternatively if you already have your own pre-prepared source tree you can specify -n/--no-extract.', + group='starting', order=90) + parser_modify.add_argument('recipename', help='Name of existing recipe to edit (just name - no version, path or extension)') + parser_modify.add_argument('srctree', nargs='?', help='Path to external source tree. If not specified, a subdirectory of %s will be used.' % defsrctree) + parser_modify.add_argument('--wildcard', '-w', action="store_true", help='Use wildcard for unversioned bbappend') + group = parser_modify.add_mutually_exclusive_group() + group.add_argument('--extract', '-x', action="store_true", help='Extract source for recipe (default)') + group.add_argument('--no-extract', '-n', action="store_true", help='Do not extract source, expect it to exist') + group = parser_modify.add_mutually_exclusive_group() + group.add_argument('--same-dir', '-s', help='Build in same directory as source', action="store_true") + group.add_argument('--no-same-dir', help='Force build in a separate build directory', action="store_true") + parser_modify.add_argument('--branch', '-b', default="devtool", help='Name for development branch to checkout (when not using -n/--no-extract) (default "%(default)s")') + parser_modify.add_argument('--keep-temp', help='Keep temporary directory (for debugging)', action="store_true") + parser_modify.set_defaults(func=modify) + + parser_extract = subparsers.add_parser('extract', help='Extract the source for an existing recipe', + description='Extracts the source for an existing recipe', + group='advanced') + parser_extract.add_argument('recipename', help='Name of recipe to extract the source for') + parser_extract.add_argument('srctree', help='Path to where to extract the source tree') + parser_extract.add_argument('--branch', '-b', default="devtool", help='Name for development branch to checkout (default "%(default)s")') + parser_extract.add_argument('--keep-temp', action="store_true", help='Keep temporary directory (for debugging)') + parser_extract.set_defaults(func=extract, no_workspace=True) + + parser_sync = subparsers.add_parser('sync', help='Synchronize the source tree for an existing recipe', + description='Synchronize the previously extracted source tree for an existing recipe', + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + group='advanced') + parser_sync.add_argument('recipename', help='Name of recipe to sync the source for') + parser_sync.add_argument('srctree', help='Path to the source tree') + parser_sync.add_argument('--branch', '-b', default="devtool", help='Name for development branch to checkout') + parser_sync.add_argument('--keep-temp', action="store_true", help='Keep temporary directory (for debugging)') + parser_sync.set_defaults(func=sync) + + parser_rename = subparsers.add_parser('rename', help='Rename a recipe file in the workspace', + description='Renames the recipe file for a recipe in the workspace, changing the name or version part or both, ensuring that all references within the workspace are updated at the same time. Only works when the recipe file itself is in the workspace, e.g. after devtool add. Particularly useful when devtool add did not automatically determine the correct name.', + group='working', order=10) + parser_rename.add_argument('recipename', help='Current name of recipe to rename') + parser_rename.add_argument('newname', nargs='?', help='New name for recipe (optional, not needed if you only want to change the version)') + parser_rename.add_argument('--version', '-V', help='Change the version (NOTE: this does not change the version fetched by the recipe, just the version in the recipe file name)') + parser_rename.add_argument('--no-srctree', '-s', action='store_true', help='Do not rename the source tree directory (if the default source tree path has been used) - keeping the old name may be desirable if there are internal/other external references to this path') + parser_rename.set_defaults(func=rename) + + parser_update_recipe = subparsers.add_parser('update-recipe', help='Apply changes from external source tree to recipe', + description='Applies changes from external source tree to a recipe (updating/adding/removing patches as necessary, or by updating SRCREV). Note that these changes need to have been committed to the git repository in order to be recognised.', + group='working', order=-90) + parser_update_recipe.add_argument('recipename', help='Name of recipe to update') + parser_update_recipe.add_argument('--mode', '-m', choices=['patch', 'srcrev', 'auto'], default='auto', help='Update mode (where %(metavar)s is %(choices)s; default is %(default)s)', metavar='MODE') + parser_update_recipe.add_argument('--initial-rev', help='Override starting revision for patches') + parser_update_recipe.add_argument('--append', '-a', help='Write changes to a bbappend in the specified layer instead of the recipe', metavar='LAYERDIR') + parser_update_recipe.add_argument('--wildcard-version', '-w', help='In conjunction with -a/--append, use a wildcard to make the bbappend apply to any recipe version', action='store_true') + parser_update_recipe.add_argument('--no-remove', '-n', action="store_true", help='Don\'t remove patches, only add or update') + parser_update_recipe.set_defaults(func=update_recipe) + + parser_status = subparsers.add_parser('status', help='Show workspace status', + description='Lists recipes currently in your workspace and the paths to their respective external source trees', + group='info', order=100) + parser_status.set_defaults(func=status) + + parser_reset = subparsers.add_parser('reset', help='Remove a recipe from your workspace', + description='Removes the specified recipe(s) from your workspace (resetting its state back to that defined by the metadata).', + group='working', order=-100) + parser_reset.add_argument('recipename', nargs='*', help='Recipe to reset') + parser_reset.add_argument('--all', '-a', action="store_true", help='Reset all recipes (clear workspace)') + parser_reset.add_argument('--no-clean', '-n', action="store_true", help='Don\'t clean the sysroot to remove recipe output') + parser_reset.set_defaults(func=reset) + + parser_finish = subparsers.add_parser('finish', help='Finish working on a recipe in your workspace', + description='Pushes any committed changes to the specified recipe to the specified layer and removes it from your workspace. Roughly equivalent to an update-recipe followed by reset, except the update-recipe step will do the "right thing" depending on the recipe and the destination layer specified.', + group='working', order=-100) + parser_finish.add_argument('recipename', help='Recipe to finish') + parser_finish.add_argument('destination', help='Layer/path to put recipe into. Can be the name of a layer configured in your bblayers.conf, the path to the base of a layer, or a partial path inside a layer. %(prog)s will attempt to complete the path based on the layer\'s structure.') + parser_finish.add_argument('--mode', '-m', choices=['patch', 'srcrev', 'auto'], default='auto', help='Update mode (where %(metavar)s is %(choices)s; default is %(default)s)', metavar='MODE') + parser_finish.add_argument('--initial-rev', help='Override starting revision for patches') + parser_finish.set_defaults(func=finish) diff --git a/scripts/lib/devtool/upgrade.py b/scripts/lib/devtool/upgrade.py new file mode 100644 index 0000000000..05fb9e5ed0 --- /dev/null +++ b/scripts/lib/devtool/upgrade.py @@ -0,0 +1,409 @@ +# Development tool - upgrade command plugin +# +# Copyright (C) 2014-2015 Intel Corporation +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +# +"""Devtool upgrade plugin""" + +import os +import sys +import re +import shutil +import tempfile +import logging +import argparse +import scriptutils +import errno +import bb + +devtool_path = os.path.dirname(os.path.realpath(__file__)) + '/../../../meta/lib' +sys.path = sys.path + [devtool_path] + +import oe.recipeutils +from devtool import standard +from devtool import exec_build_env_command, setup_tinfoil, DevtoolError, parse_recipe, use_external_build + +logger = logging.getLogger('devtool') + +def _run(cmd, cwd=''): + logger.debug("Running command %s> %s" % (cwd,cmd)) + return bb.process.run('%s' % cmd, cwd=cwd) + +def _get_srctree(tmpdir): + srctree = tmpdir + dirs = os.listdir(tmpdir) + if len(dirs) == 1: + srctree = os.path.join(tmpdir, dirs[0]) + return srctree + +def _copy_source_code(orig, dest): + for path in standard._ls_tree(orig): + dest_dir = os.path.join(dest, os.path.dirname(path)) + bb.utils.mkdirhier(dest_dir) + dest_path = os.path.join(dest, path) + shutil.move(os.path.join(orig, path), dest_path) + +def _get_checksums(rf): + import re + checksums = {} + with open(rf) as f: + for line in f: + for cs in ['md5sum', 'sha256sum']: + m = re.match("^SRC_URI\[%s\].*=.*\"(.*)\"" % cs, line) + if m: + checksums[cs] = m.group(1) + return checksums + +def _remove_patch_dirs(recipefolder): + for root, dirs, files in os.walk(recipefolder): + for d in dirs: + shutil.rmtree(os.path.join(root,d)) + +def _recipe_contains(rd, var): + rf = rd.getVar('FILE') + varfiles = oe.recipeutils.get_var_files(rf, [var], rd) + for var, fn in varfiles.items(): + if fn and fn.startswith(os.path.dirname(rf) + os.sep): + return True + return False + +def _rename_recipe_dirs(oldpv, newpv, path): + for root, dirs, files in os.walk(path): + # Rename directories with the version in their name + for olddir in dirs: + if olddir.find(oldpv) != -1: + newdir = olddir.replace(oldpv, newpv) + if olddir != newdir: + shutil.move(os.path.join(path, olddir), os.path.join(path, newdir)) + # Rename any inc files with the version in their name (unusual, but possible) + for oldfile in files: + if oldfile.endswith('.inc'): + if oldfile.find(oldpv) != -1: + newfile = oldfile.replace(oldpv, newpv) + if oldfile != newfile: + os.rename(os.path.join(path, oldfile), os.path.join(path, newfile)) + +def _rename_recipe_file(oldrecipe, bpn, oldpv, newpv, path): + oldrecipe = os.path.basename(oldrecipe) + if oldrecipe.endswith('_%s.bb' % oldpv): + newrecipe = '%s_%s.bb' % (bpn, newpv) + if oldrecipe != newrecipe: + shutil.move(os.path.join(path, oldrecipe), os.path.join(path, newrecipe)) + else: + newrecipe = oldrecipe + return os.path.join(path, newrecipe) + +def _rename_recipe_files(oldrecipe, bpn, oldpv, newpv, path): + _rename_recipe_dirs(oldpv, newpv, path) + return _rename_recipe_file(oldrecipe, bpn, oldpv, newpv, path) + +def _write_append(rc, srctree, same_dir, no_same_dir, rev, copied, workspace, d): + """Writes an append file""" + if not os.path.exists(rc): + raise DevtoolError("bbappend not created because %s does not exist" % rc) + + appendpath = os.path.join(workspace, 'appends') + if not os.path.exists(appendpath): + bb.utils.mkdirhier(appendpath) + + brf = os.path.basename(os.path.splitext(rc)[0]) # rc basename + + srctree = os.path.abspath(srctree) + pn = d.getVar('PN') + af = os.path.join(appendpath, '%s.bbappend' % brf) + with open(af, 'w') as f: + f.write('FILESEXTRAPATHS_prepend := "${THISDIR}/${PN}:"\n\n') + f.write('inherit externalsrc\n') + f.write(('# NOTE: We use pn- overrides here to avoid affecting' + 'multiple variants in the case where the recipe uses BBCLASSEXTEND\n')) + f.write('EXTERNALSRC_pn-%s = "%s"\n' % (pn, srctree)) + b_is_s = use_external_build(same_dir, no_same_dir, d) + if b_is_s: + f.write('EXTERNALSRC_BUILD_pn-%s = "%s"\n' % (pn, srctree)) + f.write('\n') + if rev: + f.write('# initial_rev: %s\n' % rev) + if copied: + f.write('# original_path: %s\n' % os.path.dirname(d.getVar('FILE'))) + f.write('# original_files: %s\n' % ' '.join(copied)) + return af + +def _cleanup_on_error(rf, srctree): + rfp = os.path.split(rf)[0] # recipe folder + rfpp = os.path.split(rfp)[0] # recipes folder + if os.path.exists(rfp): + shutil.rmtree(b) + if not len(os.listdir(rfpp)): + os.rmdir(rfpp) + srctree = os.path.abspath(srctree) + if os.path.exists(srctree): + shutil.rmtree(srctree) + +def _upgrade_error(e, rf, srctree): + if rf: + cleanup_on_error(rf, srctree) + logger.error(e) + raise DevtoolError(e) + +def _get_uri(rd): + srcuris = rd.getVar('SRC_URI').split() + if not len(srcuris): + raise DevtoolError('SRC_URI not found on recipe') + # Get first non-local entry in SRC_URI - usually by convention it's + # the first entry, but not always! + srcuri = None + for entry in srcuris: + if not entry.startswith('file://'): + srcuri = entry + break + if not srcuri: + raise DevtoolError('Unable to find non-local entry in SRC_URI') + srcrev = '${AUTOREV}' + if '://' in srcuri: + # Fetch a URL + rev_re = re.compile(';rev=([^;]+)') + res = rev_re.search(srcuri) + if res: + srcrev = res.group(1) + srcuri = rev_re.sub('', srcuri) + return srcuri, srcrev + +def _extract_new_source(newpv, srctree, no_patch, srcrev, branch, keep_temp, tinfoil, rd): + """Extract sources of a recipe with a new version""" + + def __run(cmd): + """Simple wrapper which calls _run with srctree as cwd""" + return _run(cmd, srctree) + + crd = rd.createCopy() + + pv = crd.getVar('PV') + crd.setVar('PV', newpv) + + tmpsrctree = None + uri, rev = _get_uri(crd) + if srcrev: + rev = srcrev + if uri.startswith('git://'): + __run('git fetch') + __run('git checkout %s' % rev) + __run('git tag -f devtool-base-new') + md5 = None + sha256 = None + else: + __run('git checkout devtool-base -b devtool-%s' % newpv) + + tmpdir = tempfile.mkdtemp(prefix='devtool') + try: + md5, sha256 = scriptutils.fetch_uri(tinfoil.config_data, uri, tmpdir, rev) + except bb.fetch2.FetchError as e: + raise DevtoolError(e) + + tmpsrctree = _get_srctree(tmpdir) + srctree = os.path.abspath(srctree) + + # Delete all sources so we ensure no stray files are left over + for item in os.listdir(srctree): + if item in ['.git', 'oe-local-files']: + continue + itempath = os.path.join(srctree, item) + if os.path.isdir(itempath): + shutil.rmtree(itempath) + else: + os.remove(itempath) + + # Copy in new ones + _copy_source_code(tmpsrctree, srctree) + + (stdout,_) = __run('git ls-files --modified --others --exclude-standard') + for f in stdout.splitlines(): + __run('git add "%s"' % f) + + useroptions = [] + oe.patch.GitApplyTree.gitCommandUserOptions(useroptions, d=rd) + __run('git %s commit -q -m "Commit of upstream changes at version %s" --allow-empty' % (' '.join(useroptions), newpv)) + __run('git tag -f devtool-base-%s' % newpv) + + (stdout, _) = __run('git rev-parse HEAD') + rev = stdout.rstrip() + + if no_patch: + patches = oe.recipeutils.get_recipe_patches(crd) + if len(patches): + logger.warn('By user choice, the following patches will NOT be applied') + for patch in patches: + logger.warn("%s" % os.path.basename(patch)) + else: + __run('git checkout devtool-patched -b %s' % branch) + skiptag = False + try: + __run('git rebase %s' % rev) + except bb.process.ExecutionError as e: + skiptag = True + if 'conflict' in e.stdout: + logger.warn('Command \'%s\' failed:\n%s\n\nYou will need to resolve conflicts in order to complete the upgrade.' % (e.command, e.stdout.rstrip())) + else: + logger.warn('Command \'%s\' failed:\n%s' % (e.command, e.stdout)) + if not skiptag: + if uri.startswith('git://'): + suffix = 'new' + else: + suffix = newpv + __run('git tag -f devtool-patched-%s' % suffix) + + if tmpsrctree: + if keep_temp: + logger.info('Preserving temporary directory %s' % tmpsrctree) + else: + shutil.rmtree(tmpsrctree) + + return (rev, md5, sha256) + +def _create_new_recipe(newpv, md5, sha256, srcrev, srcbranch, workspace, tinfoil, rd): + """Creates the new recipe under workspace""" + + bpn = rd.getVar('BPN') + path = os.path.join(workspace, 'recipes', bpn) + bb.utils.mkdirhier(path) + copied, _ = oe.recipeutils.copy_recipe_files(rd, path) + + oldpv = rd.getVar('PV') + if not newpv: + newpv = oldpv + origpath = rd.getVar('FILE') + fullpath = _rename_recipe_files(origpath, bpn, oldpv, newpv, path) + logger.debug('Upgraded %s => %s' % (origpath, fullpath)) + + newvalues = {} + if _recipe_contains(rd, 'PV') and newpv != oldpv: + newvalues['PV'] = newpv + + if srcrev: + newvalues['SRCREV'] = srcrev + + if srcbranch: + src_uri = oe.recipeutils.split_var_value(rd.getVar('SRC_URI', False) or '') + changed = False + replacing = True + new_src_uri = [] + for entry in src_uri: + scheme, network, path, user, passwd, params = bb.fetch2.decodeurl(entry) + if replacing and scheme in ['git', 'gitsm']: + branch = params.get('branch', 'master') + if rd.expand(branch) != srcbranch: + # Handle case where branch is set through a variable + res = re.match(r'\$\{([^}@]+)\}', branch) + if res: + newvalues[res.group(1)] = srcbranch + # We know we won't change SRC_URI now, so break out + break + else: + params['branch'] = srcbranch + entry = bb.fetch2.encodeurl((scheme, network, path, user, passwd, params)) + changed = True + replacing = False + new_src_uri.append(entry) + if changed: + newvalues['SRC_URI'] = ' '.join(new_src_uri) + + newvalues['PR'] = None + + if md5 and sha256: + newvalues['SRC_URI[md5sum]'] = md5 + newvalues['SRC_URI[sha256sum]'] = sha256 + + rd = tinfoil.parse_recipe_file(fullpath, False) + oe.recipeutils.patch_recipe(rd, fullpath, newvalues) + + return fullpath, copied + +def upgrade(args, config, basepath, workspace): + """Entry point for the devtool 'upgrade' subcommand""" + + if args.recipename in workspace: + raise DevtoolError("recipe %s is already in your workspace" % args.recipename) + if not args.version and not args.srcrev: + raise DevtoolError("You must provide a version using the --version/-V option, or for recipes that fetch from an SCM such as git, the --srcrev/-S option") + if args.srcbranch and not args.srcrev: + raise DevtoolError("If you specify --srcbranch/-B then you must use --srcrev/-S to specify the revision" % args.recipename) + + tinfoil = setup_tinfoil(basepath=basepath, tracking=True) + try: + rd = parse_recipe(config, tinfoil, args.recipename, True) + if not rd: + return 1 + + pn = rd.getVar('PN') + if pn != args.recipename: + logger.info('Mapping %s to %s' % (args.recipename, pn)) + if pn in workspace: + raise DevtoolError("recipe %s is already in your workspace" % pn) + + if args.srctree: + srctree = os.path.abspath(args.srctree) + else: + srctree = standard.get_default_srctree(config, pn) + + standard._check_compatible_recipe(pn, rd) + old_srcrev = rd.getVar('SRCREV') + if old_srcrev == 'INVALID': + old_srcrev = None + if old_srcrev and not args.srcrev: + raise DevtoolError("Recipe specifies a SRCREV value; you must specify a new one when upgrading") + if rd.getVar('PV') == args.version and old_srcrev == args.srcrev: + raise DevtoolError("Current and upgrade versions are the same version") + + rf = None + try: + rev1 = standard._extract_source(srctree, False, 'devtool-orig', False, rd, tinfoil) + rev2, md5, sha256 = _extract_new_source(args.version, srctree, args.no_patch, + args.srcrev, args.branch, args.keep_temp, + tinfoil, rd) + rf, copied = _create_new_recipe(args.version, md5, sha256, args.srcrev, args.srcbranch, config.workspace_path, tinfoil, rd) + except bb.process.CmdError as e: + _upgrade_error(e, rf, srctree) + except DevtoolError as e: + _upgrade_error(e, rf, srctree) + standard._add_md5(config, pn, os.path.dirname(rf)) + + af = _write_append(rf, srctree, args.same_dir, args.no_same_dir, rev2, + copied, config.workspace_path, rd) + standard._add_md5(config, pn, af) + logger.info('Upgraded source extracted to %s' % srctree) + logger.info('New recipe is %s' % rf) + finally: + tinfoil.shutdown() + return 0 + +def register_commands(subparsers, context): + """Register devtool subcommands from this plugin""" + + defsrctree = standard.get_default_srctree(context.config) + + parser_upgrade = subparsers.add_parser('upgrade', help='Upgrade an existing recipe', + description='Upgrades an existing recipe to a new upstream version. Puts the upgraded recipe file into the workspace along with any associated files, and extracts the source tree to a specified location (in case patches need rebasing or adding to as a result of the upgrade).', + group='starting') + parser_upgrade.add_argument('recipename', help='Name of recipe to upgrade (just name - no version, path or extension)') + parser_upgrade.add_argument('srctree', nargs='?', help='Path to where to extract the source tree. If not specified, a subdirectory of %s will be used.' % defsrctree) + parser_upgrade.add_argument('--version', '-V', help='Version to upgrade to (PV)') + parser_upgrade.add_argument('--srcrev', '-S', help='Source revision to upgrade to (required if fetching from an SCM such as git)') + parser_upgrade.add_argument('--srcbranch', '-B', help='Branch in source repository containing the revision to use (if fetching from an SCM such as git)') + parser_upgrade.add_argument('--branch', '-b', default="devtool", help='Name for new development branch to checkout (default "%(default)s")') + parser_upgrade.add_argument('--no-patch', action="store_true", help='Do not apply patches from the recipe to the new source code') + group = parser_upgrade.add_mutually_exclusive_group() + group.add_argument('--same-dir', '-s', help='Build in same directory as source', action="store_true") + group.add_argument('--no-same-dir', help='Force build in a separate build directory', action="store_true") + parser_upgrade.add_argument('--keep-temp', action="store_true", help='Keep temporary directory (for debugging)') + parser_upgrade.set_defaults(func=upgrade) diff --git a/scripts/lib/devtool/utilcmds.py b/scripts/lib/devtool/utilcmds.py new file mode 100644 index 0000000000..0437e6417c --- /dev/null +++ b/scripts/lib/devtool/utilcmds.py @@ -0,0 +1,233 @@ +# Development tool - utility commands plugin +# +# Copyright (C) 2015-2016 Intel Corporation +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +"""Devtool utility plugins""" + +import os +import sys +import shutil +import tempfile +import logging +import argparse +import subprocess +import scriptutils +from devtool import exec_build_env_command, setup_tinfoil, check_workspace_recipe, DevtoolError +from devtool import parse_recipe + +logger = logging.getLogger('devtool') + + +def edit_recipe(args, config, basepath, workspace): + """Entry point for the devtool 'edit-recipe' subcommand""" + if args.any_recipe: + tinfoil = setup_tinfoil(config_only=False, basepath=basepath) + try: + rd = parse_recipe(config, tinfoil, args.recipename, True) + if not rd: + return 1 + recipefile = rd.getVar('FILE') + finally: + tinfoil.shutdown() + else: + check_workspace_recipe(workspace, args.recipename) + recipefile = workspace[args.recipename]['recipefile'] + if not recipefile: + raise DevtoolError("Recipe file for %s is not under the workspace" % + args.recipename) + + return scriptutils.run_editor(recipefile) + + +def configure_help(args, config, basepath, workspace): + """Entry point for the devtool 'configure-help' subcommand""" + import oe.utils + + check_workspace_recipe(workspace, args.recipename) + tinfoil = setup_tinfoil(config_only=False, basepath=basepath) + try: + rd = parse_recipe(config, tinfoil, args.recipename, appends=True, filter_workspace=False) + if not rd: + return 1 + b = rd.getVar('B') + s = rd.getVar('S') + configurescript = os.path.join(s, 'configure') + confdisabled = 'noexec' in rd.getVarFlags('do_configure') or 'do_configure' not in (rd.getVar('__BBTASKS', False) or []) + configureopts = oe.utils.squashspaces(rd.getVar('CONFIGUREOPTS') or '') + extra_oeconf = oe.utils.squashspaces(rd.getVar('EXTRA_OECONF') or '') + extra_oecmake = oe.utils.squashspaces(rd.getVar('EXTRA_OECMAKE') or '') + do_configure = rd.getVar('do_configure') or '' + do_configure_noexpand = rd.getVar('do_configure', False) or '' + packageconfig = rd.getVarFlags('PACKAGECONFIG') or [] + autotools = bb.data.inherits_class('autotools', rd) and ('oe_runconf' in do_configure or 'autotools_do_configure' in do_configure) + cmake = bb.data.inherits_class('cmake', rd) and ('cmake_do_configure' in do_configure) + cmake_do_configure = rd.getVar('cmake_do_configure') + pn = rd.getVar('PN') + finally: + tinfoil.shutdown() + + if 'doc' in packageconfig: + del packageconfig['doc'] + + if autotools and not os.path.exists(configurescript): + logger.info('Running do_configure to generate configure script') + try: + stdout, _ = exec_build_env_command(config.init_path, basepath, + 'bitbake -c configure %s' % args.recipename, + stderr=subprocess.STDOUT) + except bb.process.ExecutionError: + pass + + if confdisabled or do_configure.strip() in ('', ':'): + raise DevtoolError("do_configure task has been disabled for this recipe") + elif args.no_pager and not os.path.exists(configurescript): + raise DevtoolError("No configure script found and no other information to display") + else: + configopttext = '' + if autotools and configureopts: + configopttext = ''' +Arguments currently passed to the configure script: + +%s + +Some of those are fixed.''' % (configureopts + ' ' + extra_oeconf) + if extra_oeconf: + configopttext += ''' The ones that are specified through EXTRA_OECONF (which you can change or add to easily): + +%s''' % extra_oeconf + + elif cmake: + in_cmake = False + cmake_cmd = '' + for line in cmake_do_configure.splitlines(): + if in_cmake: + cmake_cmd = cmake_cmd + ' ' + line.strip().rstrip('\\') + if not line.endswith('\\'): + break + if line.lstrip().startswith('cmake '): + cmake_cmd = line.strip().rstrip('\\') + if line.endswith('\\'): + in_cmake = True + else: + break + if cmake_cmd: + configopttext = ''' +The current cmake command line: + +%s + +Arguments specified through EXTRA_OECMAKE (which you can change or add to easily) + +%s''' % (oe.utils.squashspaces(cmake_cmd), extra_oecmake) + else: + configopttext = ''' +The current implementation of cmake_do_configure: + +cmake_do_configure() { +%s +} + +Arguments specified through EXTRA_OECMAKE (which you can change or add to easily) + +%s''' % (cmake_do_configure.rstrip(), extra_oecmake) + + elif do_configure: + configopttext = ''' +The current implementation of do_configure: + +do_configure() { +%s +}''' % do_configure.rstrip() + if '${EXTRA_OECONF}' in do_configure_noexpand: + configopttext += ''' + +Arguments specified through EXTRA_OECONF (which you can change or add to easily): + +%s''' % extra_oeconf + + if packageconfig: + configopttext += ''' + +Some of these options may be controlled through PACKAGECONFIG; for more details please see the recipe.''' + + if args.arg: + helpargs = ' '.join(args.arg) + elif cmake: + helpargs = '-LH' + else: + helpargs = '--help' + + msg = '''configure information for %s +------------------------------------------ +%s''' % (pn, configopttext) + + if cmake: + msg += ''' + +The cmake %s output for %s follows. After "-- Cache values" you should see a list of variables you can add to EXTRA_OECMAKE (prefixed with -D and suffixed with = followed by the desired value, without any spaces). +------------------------------------------''' % (helpargs, pn) + elif os.path.exists(configurescript): + msg += ''' + +The ./configure %s output for %s follows. +------------------------------------------''' % (helpargs, pn) + + olddir = os.getcwd() + tmppath = tempfile.mkdtemp() + with tempfile.NamedTemporaryFile('w', delete=False) as tf: + if not args.no_header: + tf.write(msg + '\n') + tf.close() + try: + try: + cmd = 'cat %s' % tf.name + if cmake: + cmd += '; cmake %s %s 2>&1' % (helpargs, s) + os.chdir(b) + elif os.path.exists(configurescript): + cmd += '; %s %s' % (configurescript, helpargs) + if sys.stdout.isatty() and not args.no_pager: + pager = os.environ.get('PAGER', 'less') + cmd = '(%s) | %s' % (cmd, pager) + subprocess.check_call(cmd, shell=True) + except subprocess.CalledProcessError as e: + return e.returncode + finally: + os.chdir(olddir) + shutil.rmtree(tmppath) + os.remove(tf.name) + + +def register_commands(subparsers, context): + """Register devtool subcommands from this plugin""" + parser_edit_recipe = subparsers.add_parser('edit-recipe', help='Edit a recipe file in your workspace', + description='Runs the default editor (as specified by the EDITOR variable) on the specified recipe. Note that the recipe file itself must be in the workspace (i.e. as a result of "devtool add" or "devtool upgrade"); you can override this with the -a/--any-recipe option.', + group='working') + parser_edit_recipe.add_argument('recipename', help='Recipe to edit') + parser_edit_recipe.add_argument('--any-recipe', '-a', action="store_true", help='Edit any recipe, not just where the recipe file itself is in the workspace') + parser_edit_recipe.set_defaults(func=edit_recipe) + + # NOTE: Needed to override the usage string here since the default + # gets the order wrong - recipename must come before --arg + parser_configure_help = subparsers.add_parser('configure-help', help='Get help on configure script options', + usage='devtool configure-help [options] recipename [--arg ...]', + description='Displays the help for the configure script for the specified recipe (i.e. runs ./configure --help) prefaced by a header describing the current options being specified. Output is piped through less (or whatever PAGER is set to, if set) for easy browsing.', + group='working') + parser_configure_help.add_argument('recipename', help='Recipe to show configure help for') + parser_configure_help.add_argument('-p', '--no-pager', help='Disable paged output', action="store_true") + parser_configure_help.add_argument('-n', '--no-header', help='Disable explanatory header text', action="store_true") + parser_configure_help.add_argument('--arg', help='Pass remaining arguments to the configure script instead of --help (useful if the script has additional help options)', nargs=argparse.REMAINDER) + parser_configure_help.set_defaults(func=configure_help) diff --git a/scripts/lib/image/__init__.py b/scripts/lib/image/__init__.py deleted file mode 100644 index 1ff814e761..0000000000 --- a/scripts/lib/image/__init__.py +++ /dev/null @@ -1,22 +0,0 @@ -# -# OpenEmbedded Image tools library -# -# Copyright (c) 2013, Intel Corporation. -# All rights reserved. -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License version 2 as -# published by the Free Software Foundation. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., -# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. -# -# AUTHORS -# Tom Zanussi <tom.zanussi (at] linux.intel.com> -# diff --git a/scripts/lib/image/canned-wks/mkefidisk.wks b/scripts/lib/image/canned-wks/mkefidisk.wks deleted file mode 100644 index db86caaac6..0000000000 --- a/scripts/lib/image/canned-wks/mkefidisk.wks +++ /dev/null @@ -1,11 +0,0 @@ -# short-description: Create an EFI disk image -# long-description: Creates a partitioned EFI disk image that the user -# can directly dd to boot media. - -part /boot --source bootimg-efi --ondisk sda --label msdos --active --align 1024 - -part / --source rootfs --ondisk sda --fstype=ext3 --label platform --align 1024 - -part swap --ondisk sda --size 44 --label swap1 --fstype=swap - -bootloader --timeout=10 --append="rootwait rootfstype=ext3 console=ttyPCH0,115200 console=tty0 vmalloc=256MB snd-hda-intel.enable_msi=0" diff --git a/scripts/lib/image/config/wic.conf b/scripts/lib/image/config/wic.conf deleted file mode 100644 index e96d6aec45..0000000000 --- a/scripts/lib/image/config/wic.conf +++ /dev/null @@ -1,7 +0,0 @@ -[common] -; general settings -distro_name = OpenEmbedded - -[create] -; settings for create subcommand -runtime=native diff --git a/scripts/lib/image/engine.py b/scripts/lib/image/engine.py deleted file mode 100644 index b850bb9bfe..0000000000 --- a/scripts/lib/image/engine.py +++ /dev/null @@ -1,298 +0,0 @@ -# ex:ts=4:sw=4:sts=4:et -# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- -# -# Copyright (c) 2013, Intel Corporation. -# All rights reserved. -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License version 2 as -# published by the Free Software Foundation. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., -# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. -# -# DESCRIPTION - -# This module implements the image creation engine used by 'wic' to -# create images. The engine parses through the OpenEmbedded kickstart -# (wks) file specified and generates images that can then be directly -# written onto media. -# -# AUTHORS -# Tom Zanussi <tom.zanussi (at] linux.intel.com> -# - -import os -import sys -from abc import ABCMeta, abstractmethod -import shlex -import json -import subprocess -import shutil - -import os, sys, errno -from mic import msger, creator -from mic.utils import cmdln, misc, errors -from mic.conf import configmgr -from mic.plugin import pluginmgr -from mic.__version__ import VERSION -from mic.utils.oe.misc import * - - -def verify_build_env(): - """ - Verify that the build environment is sane. - - Returns True if it is, false otherwise - """ - try: - builddir = os.environ["BUILDDIR"] - except KeyError: - print "BUILDDIR not found, exiting. (Did you forget to source oe-init-build-env?)" - sys.exit(1) - - return True - - -def find_artifacts(image_name): - """ - Gather the build artifacts for the current image (the image_name - e.g. core-image-minimal) for the current MACHINE set in local.conf - """ - bitbake_env_lines = get_bitbake_env_lines() - - rootfs_dir = kernel_dir = hdddir = staging_data_dir = native_sysroot = "" - - for line in bitbake_env_lines.split('\n'): - if (get_line_val(line, "IMAGE_ROOTFS")): - rootfs_dir = get_line_val(line, "IMAGE_ROOTFS") - continue - if (get_line_val(line, "STAGING_KERNEL_DIR")): - kernel_dir = get_line_val(line, "STAGING_KERNEL_DIR") - continue - if (get_line_val(line, "HDDDIR")): - hdddir = get_line_val(line, "HDDDIR") - continue - if (get_line_val(line, "STAGING_DATADIR")): - staging_data_dir = get_line_val(line, "STAGING_DATADIR") - continue - if (get_line_val(line, "STAGING_DIR_NATIVE")): - native_sysroot = get_line_val(line, "STAGING_DIR_NATIVE") - continue - - return (rootfs_dir, kernel_dir, hdddir, staging_data_dir, native_sysroot) - - -CANNED_IMAGE_DIR = "lib/image/canned-wks" # relative to scripts -SCRIPTS_CANNED_IMAGE_DIR = "scripts/" + CANNED_IMAGE_DIR - -def build_canned_image_list(dl): - layers_path = get_bitbake_var("BBLAYERS") - canned_wks_layer_dirs = [] - - if layers_path is not None: - for layer_path in layers_path.split(): - path = os.path.join(layer_path, SCRIPTS_CANNED_IMAGE_DIR) - canned_wks_layer_dirs.append(path) - - path = os.path.join(dl, CANNED_IMAGE_DIR) - canned_wks_layer_dirs.append(path) - - return canned_wks_layer_dirs - -def find_canned_image(scripts_path, wks_file): - """ - Find a .wks file with the given name in the canned files dir. - - Return False if not found - """ - layers_canned_wks_dir = build_canned_image_list(scripts_path) - - for canned_wks_dir in layers_canned_wks_dir: - for root, dirs, files in os.walk(canned_wks_dir): - for file in files: - if file.endswith("~") or file.endswith("#"): - continue - if file.endswith(".wks") and wks_file + ".wks" == file: - fullpath = os.path.join(canned_wks_dir, file) - return fullpath - return None - - -def list_canned_images(scripts_path): - """ - List the .wks files in the canned image dir, minus the extension. - """ - layers_canned_wks_dir = build_canned_image_list(scripts_path) - - for canned_wks_dir in layers_canned_wks_dir: - for root, dirs, files in os.walk(canned_wks_dir): - for file in files: - if file.endswith("~") or file.endswith("#"): - continue - if file.endswith(".wks"): - fullpath = os.path.join(canned_wks_dir, file) - f = open(fullpath, "r") - lines = f.readlines() - for line in lines: - desc = "" - idx = line.find("short-description:") - if idx != -1: - desc = line[idx + len("short-description:"):].strip() - break - basename = os.path.splitext(file)[0] - print " %s\t\t%s" % (basename.ljust(30), desc) - - -def list_canned_image_help(scripts_path, fullpath): - """ - List the help and params in the specified canned image. - """ - f = open(fullpath, "r") - lines = f.readlines() - found = False - for line in lines: - if not found: - idx = line.find("long-description:") - if idx != -1: - print - print line[idx + len("long-description:"):].strip() - found = True - continue - if not line.strip(): - break - idx = line.find("#") - if idx != -1: - print line[idx + len("#:"):].rstrip() - else: - break - - -def list_source_plugins(): - """ - List the available source plugins i.e. plugins available for --source. - """ - plugins = pluginmgr.get_source_plugins() - - for plugin in plugins: - print " %s" % plugin - - -def wic_create(args, wks_file, rootfs_dir, bootimg_dir, kernel_dir, - native_sysroot, hdddir, staging_data_dir, scripts_path, - image_output_dir, debug, properties_file, properties=None): - """ - Create image - - wks_file - user-defined OE kickstart file - rootfs_dir - absolute path to the build's /rootfs dir - bootimg_dir - absolute path to the build's boot artifacts directory - kernel_dir - absolute path to the build's kernel directory - native_sysroot - absolute path to the build's native sysroots dir - hdddir - absolute path to the build's HDDDIR dir - staging_data_dir - absolute path to the build's STAGING_DATA_DIR dir - scripts_path - absolute path to /scripts dir - image_output_dir - dirname to create for image - properties_file - use values from this file if nonempty i.e no prompting - properties - use values from this string if nonempty i.e no prompting - - Normally, the values for the build artifacts values are determined - by 'wic -e' from the output of the 'bitbake -e' command given an - image name e.g. 'core-image-minimal' and a given machine set in - local.conf. If that's the case, the variables get the following - values from the output of 'bitbake -e': - - rootfs_dir: IMAGE_ROOTFS - kernel_dir: STAGING_KERNEL_DIR - native_sysroot: STAGING_DIR_NATIVE - hdddir: HDDDIR - staging_data_dir: STAGING_DATA_DIR - - In the above case, bootimg_dir remains unset and the image - creation code determines which of the passed-in directories to - use. - - In the case where the values are passed in explicitly i.e 'wic -e' - is not used but rather the individual 'wic' options are used to - explicitly specify these values, hdddir and staging_data_dir will - be unset, but bootimg_dir must be explicit i.e. explicitly set to - either hdddir or staging_data_dir, depending on the image being - generated. The other values (rootfs_dir, kernel_dir, and - native_sysroot) correspond to the same values found above via - 'bitbake -e'). - - """ - try: - oe_builddir = os.environ["BUILDDIR"] - except KeyError: - print "BUILDDIR not found, exiting. (Did you forget to source oe-init-build-env?)" - sys.exit(1) - - direct_args = list() - direct_args.insert(0, oe_builddir) - direct_args.insert(0, image_output_dir) - direct_args.insert(0, wks_file) - direct_args.insert(0, rootfs_dir) - direct_args.insert(0, bootimg_dir) - direct_args.insert(0, kernel_dir) - direct_args.insert(0, native_sysroot) - direct_args.insert(0, hdddir) - direct_args.insert(0, staging_data_dir) - direct_args.insert(0, "direct") - - if debug: - msger.set_loglevel('debug') - - cr = creator.Creator() - - cr.main(direct_args) - - print "\nThe image(s) were created using OE kickstart file:\n %s" % wks_file - - -def wic_list(args, scripts_path, properties_file): - """ - Print the complete list of properties defined by the image, or the - possible values for a particular image property. - """ - if len(args) < 1: - return False - - if len(args) == 1: - if args[0] == "images": - list_canned_images(scripts_path) - return True - elif args[0] == "source-plugins": - list_source_plugins() - return True - elif args[0] == "properties": - return True - else: - return False - - if len(args) == 2: - if args[0] == "properties": - wks_file = args[1] - print "print properties contained in wks file: %s" % wks_file - return True - elif args[0] == "property": - print "print property values for property: %s" % args[1] - return True - elif args[1] == "help": - wks_file = args[0] - fullpath = find_canned_image(scripts_path, wks_file) - if not fullpath: - print "No image named %s found, exiting. (Use 'wic list images' to list available images, or specify a fully-qualified OE kickstart (.wks) filename)\n" % wks_file - sys.exit(1) - list_canned_image_help(scripts_path, fullpath) - return True - else: - return False - - return False diff --git a/scripts/lib/mic/3rdparty/pykickstart/base.py b/scripts/lib/mic/3rdparty/pykickstart/base.py deleted file mode 100644 index e6c8f56f9d..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/base.py +++ /dev/null @@ -1,466 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2006, 2007, 2008 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -""" -Base classes for creating commands and syntax version object. - -This module exports several important base classes: - - BaseData - The base abstract class for all data objects. Data objects - are contained within a BaseHandler object. - - BaseHandler - The base abstract class from which versioned kickstart - handler are derived. Subclasses of BaseHandler hold - BaseData and KickstartCommand objects. - - DeprecatedCommand - An abstract subclass of KickstartCommand that should - be further subclassed by users of this module. When - a subclass is used, a warning message will be - printed. - - KickstartCommand - The base abstract class for all kickstart commands. - Command objects are contained within a BaseHandler - object. -""" -import gettext -gettext.textdomain("pykickstart") -_ = lambda x: gettext.ldgettext("pykickstart", x) - -import types -import warnings -from pykickstart.errors import * -from pykickstart.ko import * -from pykickstart.parser import Packages -from pykickstart.version import versionToString - -### -### COMMANDS -### -class KickstartCommand(KickstartObject): - """The base class for all kickstart commands. This is an abstract class.""" - removedKeywords = [] - removedAttrs = [] - - def __init__(self, writePriority=0, *args, **kwargs): - """Create a new KickstartCommand instance. This method must be - provided by all subclasses, but subclasses must call - KickstartCommand.__init__ first. Instance attributes: - - currentCmd -- The name of the command in the input file that - caused this handler to be run. - currentLine -- The current unprocessed line from the input file - that caused this handler to be run. - handler -- A reference to the BaseHandler subclass this - command is contained withing. This is needed to - allow referencing of Data objects. - lineno -- The current line number in the input file. - writePriority -- An integer specifying when this command should be - printed when iterating over all commands' __str__ - methods. The higher the number, the later this - command will be written. All commands with the - same priority will be written alphabetically. - """ - - # We don't want people using this class by itself. - if self.__class__ is KickstartCommand: - raise TypeError, "KickstartCommand is an abstract class." - - KickstartObject.__init__(self, *args, **kwargs) - - self.writePriority = writePriority - - # These will be set by the dispatcher. - self.currentCmd = "" - self.currentLine = "" - self.handler = None - self.lineno = 0 - - # If a subclass provides a removedKeywords list, remove all the - # members from the kwargs list before we start processing it. This - # ensures that subclasses don't continue to recognize arguments that - # were removed. - for arg in filter(kwargs.has_key, self.removedKeywords): - kwargs.pop(arg) - - def __call__(self, *args, **kwargs): - """Set multiple attributes on a subclass of KickstartCommand at once - via keyword arguments. Valid attributes are anything specified in - a subclass, but unknown attributes will be ignored. - """ - for (key, val) in kwargs.items(): - # Ignore setting attributes that were removed in a subclass, as - # if they were unknown attributes. - if key in self.removedAttrs: - continue - - if hasattr(self, key): - setattr(self, key, val) - - def __str__(self): - """Return a string formatted for output to a kickstart file. This - method must be provided by all subclasses. - """ - return KickstartObject.__str__(self) - - def parse(self, args): - """Parse the list of args and set data on the KickstartCommand object. - This method must be provided by all subclasses. - """ - raise TypeError, "parse() not implemented for KickstartCommand" - - def apply(self, instroot="/"): - """Write out the configuration related to the KickstartCommand object. - Subclasses which do not provide this method will not have their - configuration written out. - """ - return - - def dataList(self): - """For commands that can occur multiple times in a single kickstart - file (like network, part, etc.), return the list that we should - append more data objects to. - """ - return None - - def deleteRemovedAttrs(self): - """Remove all attributes from self that are given in the removedAttrs - list. This method should be called from __init__ in a subclass, - but only after the superclass's __init__ method has been called. - """ - for attr in filter(lambda k: hasattr(self, k), self.removedAttrs): - delattr(self, attr) - - # Set the contents of the opts object (an instance of optparse.Values - # returned by parse_args) as attributes on the KickstartCommand object. - # It's useful to call this from KickstartCommand subclasses after parsing - # the arguments. - def _setToSelf(self, optParser, opts): - self._setToObj(optParser, opts, self) - - # Sets the contents of the opts object (an instance of optparse.Values - # returned by parse_args) as attributes on the provided object obj. It's - # useful to call this from KickstartCommand subclasses that handle lists - # of objects (like partitions, network devices, etc.) and need to populate - # a Data object. - def _setToObj(self, optParser, opts, obj): - for key in filter (lambda k: getattr(opts, k) != None, optParser.keys()): - setattr(obj, key, getattr(opts, key)) - -class DeprecatedCommand(KickstartCommand): - """Specify that a command is deprecated and no longer has any function. - Any command that is deprecated should be subclassed from this class, - only specifying an __init__ method that calls the superclass's __init__. - This is an abstract class. - """ - def __init__(self, writePriority=None, *args, **kwargs): - # We don't want people using this class by itself. - if self.__class__ is KickstartCommand: - raise TypeError, "DeprecatedCommand is an abstract class." - - # Create a new DeprecatedCommand instance. - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - - def __str__(self): - """Placeholder since DeprecatedCommands don't work anymore.""" - return "" - - def parse(self, args): - """Print a warning message if the command is seen in the input file.""" - mapping = {"lineno": self.lineno, "cmd": self.currentCmd} - warnings.warn(_("Ignoring deprecated command on line %(lineno)s: The %(cmd)s command has been deprecated and no longer has any effect. It may be removed from future releases, which will result in a fatal error from kickstart. Please modify your kickstart file to remove this command.") % mapping, DeprecationWarning) - - -### -### HANDLERS -### -class BaseHandler(KickstartObject): - """Each version of kickstart syntax is provided by a subclass of this - class. These subclasses are what users will interact with for parsing, - extracting data, and writing out kickstart files. This is an abstract - class. - - version -- The version this syntax handler supports. This is set by - a class attribute of a BaseHandler subclass and is used to - set up the command dict. It is for read-only use. - """ - version = None - - def __init__(self, mapping=None, dataMapping=None, commandUpdates=None, - dataUpdates=None, *args, **kwargs): - """Create a new BaseHandler instance. This method must be provided by - all subclasses, but subclasses must call BaseHandler.__init__ first. - - mapping -- A custom map from command strings to classes, - useful when creating your own handler with - special command objects. It is otherwise unused - and rarely needed. If you give this argument, - the mapping takes the place of the default one - and so must include all commands you want - recognized. - dataMapping -- This is the same as mapping, but for data - objects. All the same comments apply. - commandUpdates -- This is similar to mapping, but does not take - the place of the defaults entirely. Instead, - this mapping is applied after the defaults and - updates it with just the commands you want to - modify. - dataUpdates -- This is the same as commandUpdates, but for - data objects. - - - Instance attributes: - - commands -- A mapping from a string command to a KickstartCommand - subclass object that handles it. Multiple strings can - map to the same object, but only one instance of the - command object should ever exist. Most users should - never have to deal with this directly, as it is - manipulated internally and called through dispatcher. - currentLine -- The current unprocessed line from the input file - that caused this handler to be run. - packages -- An instance of pykickstart.parser.Packages which - describes the packages section of the input file. - platform -- A string describing the hardware platform, which is - needed only by system-config-kickstart. - scripts -- A list of pykickstart.parser.Script instances, which is - populated by KickstartParser.addScript and describes the - %pre/%post/%traceback script section of the input file. - """ - - # We don't want people using this class by itself. - if self.__class__ is BaseHandler: - raise TypeError, "BaseHandler is an abstract class." - - KickstartObject.__init__(self, *args, **kwargs) - - # This isn't really a good place for these, but it's better than - # everything else I can think of. - self.scripts = [] - self.packages = Packages() - self.platform = "" - - # These will be set by the dispatcher. - self.commands = {} - self.currentLine = 0 - - # A dict keyed by an integer priority number, with each value being a - # list of KickstartCommand subclasses. This dict is maintained by - # registerCommand and used in __str__. No one else should be touching - # it. - self._writeOrder = {} - - self._registerCommands(mapping, dataMapping, commandUpdates, dataUpdates) - - def __str__(self): - """Return a string formatted for output to a kickstart file.""" - retval = "" - - if self.platform != "": - retval += "#platform=%s\n" % self.platform - - retval += "#version=%s\n" % versionToString(self.version) - - lst = self._writeOrder.keys() - lst.sort() - - for prio in lst: - for obj in self._writeOrder[prio]: - retval += obj.__str__() - - for script in self.scripts: - retval += script.__str__() - - retval += self.packages.__str__() - - return retval - - def _insertSorted(self, lst, obj): - length = len(lst) - i = 0 - - while i < length: - # If the two classes have the same name, it's because we are - # overriding an existing class with one from a later kickstart - # version, so remove the old one in favor of the new one. - if obj.__class__.__name__ > lst[i].__class__.__name__: - i += 1 - elif obj.__class__.__name__ == lst[i].__class__.__name__: - lst[i] = obj - return - elif obj.__class__.__name__ < lst[i].__class__.__name__: - break - - if i >= length: - lst.append(obj) - else: - lst.insert(i, obj) - - def _setCommand(self, cmdObj): - # Add an attribute on this version object. We need this to provide a - # way for clients to access the command objects. We also need to strip - # off the version part from the front of the name. - if cmdObj.__class__.__name__.find("_") != -1: - name = unicode(cmdObj.__class__.__name__.split("_", 1)[1]) - else: - name = unicode(cmdObj.__class__.__name__).lower() - - setattr(self, name.lower(), cmdObj) - - # Also, add the object into the _writeOrder dict in the right place. - if cmdObj.writePriority is not None: - if self._writeOrder.has_key(cmdObj.writePriority): - self._insertSorted(self._writeOrder[cmdObj.writePriority], cmdObj) - else: - self._writeOrder[cmdObj.writePriority] = [cmdObj] - - def _registerCommands(self, mapping=None, dataMapping=None, commandUpdates=None, - dataUpdates=None): - if mapping == {} or mapping == None: - from pykickstart.handlers.control import commandMap - cMap = commandMap[self.version] - else: - cMap = mapping - - if dataMapping == {} or dataMapping == None: - from pykickstart.handlers.control import dataMap - dMap = dataMap[self.version] - else: - dMap = dataMapping - - if type(commandUpdates) == types.DictType: - cMap.update(commandUpdates) - - if type(dataUpdates) == types.DictType: - dMap.update(dataUpdates) - - for (cmdName, cmdClass) in cMap.iteritems(): - # First make sure we haven't instantiated this command handler - # already. If we have, we just need to make another mapping to - # it in self.commands. - cmdObj = None - - for (key, val) in self.commands.iteritems(): - if val.__class__.__name__ == cmdClass.__name__: - cmdObj = val - break - - # If we didn't find an instance in self.commands, create one now. - if cmdObj == None: - cmdObj = cmdClass() - self._setCommand(cmdObj) - - # Finally, add the mapping to the commands dict. - self.commands[cmdName] = cmdObj - self.commands[cmdName].handler = self - - # We also need to create attributes for the various data objects. - # No checks here because dMap is a bijection. At least, that's what - # the comment says. Hope no one screws that up. - for (dataName, dataClass) in dMap.iteritems(): - setattr(self, dataName, dataClass) - - def dispatcher(self, args, lineno): - """Call the appropriate KickstartCommand handler for the current line - in the kickstart file. A handler for the current command should - be registered, though a handler of None is not an error. Returns - the data object returned by KickstartCommand.parse. - - args -- A list of arguments to the current command - lineno -- The line number in the file, for error reporting - """ - cmd = args[0] - - if not self.commands.has_key(cmd): - raise KickstartParseError, formatErrorMsg(lineno, msg=_("Unknown command: %s" % cmd)) - elif self.commands[cmd] != None: - self.commands[cmd].currentCmd = cmd - self.commands[cmd].currentLine = self.currentLine - self.commands[cmd].lineno = lineno - - # The parser returns the data object that was modified. This could - # be a BaseData subclass that should be put into a list, or it - # could be the command handler object itself. - obj = self.commands[cmd].parse(args[1:]) - lst = self.commands[cmd].dataList() - if lst is not None: - lst.append(obj) - - return obj - - def maskAllExcept(self, lst): - """Set all entries in the commands dict to None, except the ones in - the lst. All other commands will not be processed. - """ - self._writeOrder = {} - - for (key, val) in self.commands.iteritems(): - if not key in lst: - self.commands[key] = None - - def hasCommand(self, cmd): - """Return true if there is a handler for the string cmd.""" - return hasattr(self, cmd) - - -### -### DATA -### -class BaseData(KickstartObject): - """The base class for all data objects. This is an abstract class.""" - removedKeywords = [] - removedAttrs = [] - - def __init__(self, *args, **kwargs): - """Create a new BaseData instance. - - lineno -- Line number in the ks-file where this object was defined - """ - - # We don't want people using this class by itself. - if self.__class__ is BaseData: - raise TypeError, "BaseData is an abstract class." - - KickstartObject.__init__(self, *args, **kwargs) - self.lineno = 0 - - def __str__(self): - """Return a string formatted for output to a kickstart file.""" - return "" - - def __call__(self, *args, **kwargs): - """Set multiple attributes on a subclass of BaseData at once via - keyword arguments. Valid attributes are anything specified in a - subclass, but unknown attributes will be ignored. - """ - for (key, val) in kwargs.items(): - # Ignore setting attributes that were removed in a subclass, as - # if they were unknown attributes. - if key in self.removedAttrs: - continue - - if hasattr(self, key): - setattr(self, key, val) - - def deleteRemovedAttrs(self): - """Remove all attributes from self that are given in the removedAttrs - list. This method should be called from __init__ in a subclass, - but only after the superclass's __init__ method has been called. - """ - for attr in filter(lambda k: hasattr(self, k), self.removedAttrs): - delattr(self, attr) diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/__init__.py b/scripts/lib/mic/3rdparty/pykickstart/commands/__init__.py deleted file mode 100644 index da48ff50d5..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/__init__.py +++ /dev/null @@ -1,26 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2009 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -import authconfig, autopart, autostep, bootloader, clearpart, device -import deviceprobe, displaymode, dmraid, driverdisk, fcoe, firewall, firstboot -import group, ignoredisk, interactive, iscsi, iscsiname, key, keyboard, lang -import langsupport, lilocheck, logging, logvol, mediacheck, method, monitor -import mouse, multipath, network, partition, raid, reboot, repo, rescue, rootpw -import selinux, services, skipx, sshpw, timezone, updates, upgrade, user, vnc -import volgroup, xconfig, zerombr, zfcp diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/authconfig.py b/scripts/lib/mic/3rdparty/pykickstart/commands/authconfig.py deleted file mode 100644 index 9af9c0ff14..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/authconfig.py +++ /dev/null @@ -1,40 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * - -class FC3_Authconfig(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, *args, **kwargs) - self.authconfig = kwargs.get("authconfig", "") - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.authconfig: - retval += "# System authorization information\nauth %s\n" % self.authconfig - - return retval - - def parse(self, args): - self.authconfig = self.currentLine[len(self.currentCmd):].strip() - return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/autopart.py b/scripts/lib/mic/3rdparty/pykickstart/commands/autopart.py deleted file mode 100644 index cf28b5c7f7..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/autopart.py +++ /dev/null @@ -1,119 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007, 2008 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC3_AutoPart(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=100, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.autopart = kwargs.get("autopart", False) - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.autopart: - retval += "autopart\n" - - return retval - - def parse(self, args): - if len(args) > 0: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s does not take any arguments") % "autopart") - - self.autopart = True - return self - -class F9_AutoPart(FC3_AutoPart): - removedKeywords = FC3_AutoPart.removedKeywords - removedAttrs = FC3_AutoPart.removedAttrs - - def __init__(self, writePriority=100, *args, **kwargs): - FC3_AutoPart.__init__(self, writePriority=writePriority, *args, **kwargs) - self.encrypted = kwargs.get("encrypted", False) - self.passphrase = kwargs.get("passphrase", "") - - self.op = self._getParser() - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.autopart: - retval += "autopart" - - if self.encrypted: - retval += " --encrypted" - - if self.passphrase != "": - retval += " --passphrase=\"%s\""% self.passphrase - - if retval != "": - retval += "\n" - - return retval - - def _getParser(self): - op = KSOptionParser() - op.add_option("--encrypted", action="store_true", default=False) - op.add_option("--passphrase") - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - self._setToSelf(self.op, opts) - self.autopart = True - return self - -class F12_AutoPart(F9_AutoPart): - removedKeywords = F9_AutoPart.removedKeywords - removedAttrs = F9_AutoPart.removedAttrs - - def __init__(self, writePriority=100, *args, **kwargs): - F9_AutoPart.__init__(self, writePriority=writePriority, *args, **kwargs) - - self.escrowcert = kwargs.get("escrowcert", "") - self.backuppassphrase = kwargs.get("backuppassphrase", False) - - def __str__(self): - retval = F9_AutoPart.__str__(self) - - if self.encrypted and self.escrowcert != "": - retval = retval.strip() - - retval += " --escrowcert=\"%s\"" % self.escrowcert - - if self.backuppassphrase: - retval += " --backuppassphrase" - - retval += "\n" - - return retval - - def _getParser(self): - op = F9_AutoPart._getParser(self) - op.add_option("--escrowcert") - op.add_option("--backuppassphrase", action="store_true", default=False) - return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/autostep.py b/scripts/lib/mic/3rdparty/pykickstart/commands/autostep.py deleted file mode 100644 index e6ae71cefc..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/autostep.py +++ /dev/null @@ -1,55 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.options import * - -class FC3_AutoStep(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.autostep = kwargs.get("autostep", False) - self.autoscreenshot = kwargs.get("autoscreenshot", False) - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.autostep: - if self.autoscreenshot: - retval += "autostep --autoscreenshot\n" - else: - retval += "autostep\n" - - return retval - - def _getParser(self): - op = KSOptionParser() - op.add_option("--autoscreenshot", dest="autoscreenshot", - action="store_true", default=False) - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - self._setToSelf(self.op, opts) - self.autostep = True - return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/bootloader.py b/scripts/lib/mic/3rdparty/pykickstart/commands/bootloader.py deleted file mode 100644 index b227fac3be..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/bootloader.py +++ /dev/null @@ -1,265 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.options import * - -class FC3_Bootloader(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=10, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.driveorder = kwargs.get("driveorder", []) - self.appendLine = kwargs.get("appendLine", "") - self.forceLBA = kwargs.get("forceLBA", False) - self.linear = kwargs.get("linear", True) - self.location = kwargs.get("location", "") - self.md5pass = kwargs.get("md5pass", "") - self.password = kwargs.get("password", "") - self.upgrade = kwargs.get("upgrade", False) - self.useLilo = kwargs.get("useLilo", False) - - self.deleteRemovedAttrs() - - def _getArgsAsStr(self): - retval = "" - - if self.appendLine != "": - retval += " --append=\"%s\"" % self.appendLine - if self.linear: - retval += " --linear" - if self.location: - retval += " --location=%s" % self.location - if hasattr(self, "forceLBA") and self.forceLBA: - retval += " --lba32" - if self.password != "": - retval += " --password=\"%s\"" % self.password - if self.md5pass != "": - retval += " --md5pass=\"%s\"" % self.md5pass - if self.upgrade: - retval += " --upgrade" - if self.useLilo: - retval += " --useLilo" - if len(self.driveorder) > 0: - retval += " --driveorder=\"%s\"" % ",".join(self.driveorder) - - return retval - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.location != "": - retval += "# System bootloader configuration\nbootloader" - retval += self._getArgsAsStr() + "\n" - - return retval - - def _getParser(self): - def driveorder_cb (option, opt_str, value, parser): - for d in value.split(','): - parser.values.ensure_value(option.dest, []).append(d) - - op = KSOptionParser() - op.add_option("--append", dest="appendLine") - op.add_option("--linear", dest="linear", action="store_true", - default=True) - op.add_option("--nolinear", dest="linear", action="store_false") - op.add_option("--location", dest="location", type="choice", - default="mbr", - choices=["mbr", "partition", "none", "boot"]) - op.add_option("--lba32", dest="forceLBA", action="store_true", - default=False) - op.add_option("--password", dest="password", default="") - op.add_option("--md5pass", dest="md5pass", default="") - op.add_option("--upgrade", dest="upgrade", action="store_true", - default=False) - op.add_option("--useLilo", dest="useLilo", action="store_true", - default=False) - op.add_option("--driveorder", dest="driveorder", action="callback", - callback=driveorder_cb, nargs=1, type="string") - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - self._setToSelf(self.op, opts) - - if self.currentCmd == "lilo": - self.useLilo = True - - return self - -class FC4_Bootloader(FC3_Bootloader): - removedKeywords = FC3_Bootloader.removedKeywords + ["linear", "useLilo"] - removedAttrs = FC3_Bootloader.removedAttrs + ["linear", "useLilo"] - - def __init__(self, writePriority=10, *args, **kwargs): - FC3_Bootloader.__init__(self, writePriority, *args, **kwargs) - - def _getArgsAsStr(self): - retval = "" - if self.appendLine != "": - retval += " --append=\"%s\"" % self.appendLine - if self.location: - retval += " --location=%s" % self.location - if hasattr(self, "forceLBA") and self.forceLBA: - retval += " --lba32" - if self.password != "": - retval += " --password=\"%s\"" % self.password - if self.md5pass != "": - retval += " --md5pass=\"%s\"" % self.md5pass - if self.upgrade: - retval += " --upgrade" - if len(self.driveorder) > 0: - retval += " --driveorder=\"%s\"" % ",".join(self.driveorder) - return retval - - def _getParser(self): - op = FC3_Bootloader._getParser(self) - op.remove_option("--linear") - op.remove_option("--nolinear") - op.remove_option("--useLilo") - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - self._setToSelf(self.op, opts) - return self - -class F8_Bootloader(FC4_Bootloader): - removedKeywords = FC4_Bootloader.removedKeywords - removedAttrs = FC4_Bootloader.removedAttrs - - def __init__(self, writePriority=10, *args, **kwargs): - FC4_Bootloader.__init__(self, writePriority, *args, **kwargs) - - self.timeout = kwargs.get("timeout", None) - self.default = kwargs.get("default", "") - - def _getArgsAsStr(self): - ret = FC4_Bootloader._getArgsAsStr(self) - - if self.timeout is not None: - ret += " --timeout=%d" %(self.timeout,) - if self.default: - ret += " --default=%s" %(self.default,) - - return ret - - def _getParser(self): - op = FC4_Bootloader._getParser(self) - op.add_option("--timeout", dest="timeout", type="int") - op.add_option("--default", dest="default") - return op - -class F12_Bootloader(F8_Bootloader): - removedKeywords = F8_Bootloader.removedKeywords - removedAttrs = F8_Bootloader.removedAttrs - - def _getParser(self): - op = F8_Bootloader._getParser(self) - op.add_option("--lba32", dest="forceLBA", deprecated=1, action="store_true") - return op - -class F14_Bootloader(F12_Bootloader): - removedKeywords = F12_Bootloader.removedKeywords + ["forceLBA"] - removedAttrs = F12_Bootloader.removedKeywords + ["forceLBA"] - - def _getParser(self): - op = F12_Bootloader._getParser(self) - op.remove_option("--lba32") - return op - -class F15_Bootloader(F14_Bootloader): - removedKeywords = F14_Bootloader.removedKeywords - removedAttrs = F14_Bootloader.removedAttrs - - def __init__(self, writePriority=10, *args, **kwargs): - F14_Bootloader.__init__(self, writePriority, *args, **kwargs) - - self.isCrypted = kwargs.get("isCrypted", False) - - def _getArgsAsStr(self): - ret = F14_Bootloader._getArgsAsStr(self) - - if self.isCrypted: - ret += " --iscrypted" - - return ret - - def _getParser(self): - def password_cb(option, opt_str, value, parser): - parser.values.isCrypted = True - parser.values.password = value - - op = F14_Bootloader._getParser(self) - op.add_option("--iscrypted", dest="isCrypted", action="store_true", default=False) - op.add_option("--md5pass", action="callback", callback=password_cb, nargs=1, type="string") - return op - -class RHEL5_Bootloader(FC4_Bootloader): - removedKeywords = FC4_Bootloader.removedKeywords - removedAttrs = FC4_Bootloader.removedAttrs - - def __init__(self, writePriority=10, *args, **kwargs): - FC4_Bootloader.__init__(self, writePriority, *args, **kwargs) - - self.hvArgs = kwargs.get("hvArgs", "") - - def _getArgsAsStr(self): - ret = FC4_Bootloader._getArgsAsStr(self) - - if self.hvArgs: - ret += " --hvargs=\"%s\"" %(self.hvArgs,) - - return ret - - def _getParser(self): - op = FC4_Bootloader._getParser(self) - op.add_option("--hvargs", dest="hvArgs", type="string") - return op - -class RHEL6_Bootloader(F12_Bootloader): - removedKeywords = F12_Bootloader.removedKeywords - removedAttrs = F12_Bootloader.removedAttrs - - def __init__(self, writePriority=10, *args, **kwargs): - F12_Bootloader.__init__(self, writePriority, *args, **kwargs) - - self.isCrypted = kwargs.get("isCrypted", False) - - def _getArgsAsStr(self): - ret = F12_Bootloader._getArgsAsStr(self) - - if self.isCrypted: - ret += " --iscrypted" - - return ret - - def _getParser(self): - def password_cb(option, opt_str, value, parser): - parser.values.isCrypted = True - parser.values.password = value - - op = F12_Bootloader._getParser(self) - op.add_option("--iscrypted", dest="isCrypted", action="store_true", default=False) - op.add_option("--md5pass", action="callback", callback=password_cb, nargs=1, type="string") - return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/clearpart.py b/scripts/lib/mic/3rdparty/pykickstart/commands/clearpart.py deleted file mode 100644 index a8089fcb99..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/clearpart.py +++ /dev/null @@ -1,86 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.constants import * -from pykickstart.errors import * -from pykickstart.options import * - -class FC3_ClearPart(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=120, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.drives = kwargs.get("drives", []) - self.initAll = kwargs.get("initAll", False) - self.type = kwargs.get("type", None) - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.type is None: - return retval - - if self.type == CLEARPART_TYPE_NONE: - clearstr = "--none" - elif self.type == CLEARPART_TYPE_LINUX: - clearstr = "--linux" - elif self.type == CLEARPART_TYPE_ALL: - clearstr = "--all" - else: - clearstr = "" - - if self.initAll: - initstr = "--initlabel" - else: - initstr = "" - - if len(self.drives) > 0: - drivestr = "--drives=" + ",".join(self.drives) - else: - drivestr = "" - - retval += "# Partition clearing information\nclearpart %s %s %s\n" % (clearstr, initstr, drivestr) - return retval - - def _getParser(self): - def drive_cb (option, opt_str, value, parser): - for d in value.split(','): - parser.values.ensure_value(option.dest, []).append(d) - - op = KSOptionParser() - op.add_option("--all", dest="type", action="store_const", - const=CLEARPART_TYPE_ALL) - op.add_option("--drives", dest="drives", action="callback", - callback=drive_cb, nargs=1, type="string") - op.add_option("--initlabel", dest="initAll", action="store_true", - default=False) - op.add_option("--linux", dest="type", action="store_const", - const=CLEARPART_TYPE_LINUX) - op.add_option("--none", dest="type", action="store_const", - const=CLEARPART_TYPE_NONE) - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - self._setToSelf(self.op, opts) - return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/device.py b/scripts/lib/mic/3rdparty/pykickstart/commands/device.py deleted file mode 100644 index 321410e2e2..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/device.py +++ /dev/null @@ -1,125 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.options import * - -import gettext -import warnings -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class F8_DeviceData(BaseData): - removedKeywords = BaseData.removedKeywords - removedAttrs = BaseData.removedAttrs - - def __init__(self, *args, **kwargs): - BaseData.__init__(self, *args, **kwargs) - self.moduleName = kwargs.get("moduleName", "") - self.moduleOpts = kwargs.get("moduleOpts", "") - - def __eq__(self, y): - return self.moduleName == y.moduleName - - def __str__(self): - retval = BaseData.__str__(self) - - if self.moduleName != "": - retval += "device %s" % self.moduleName - - if self.moduleOpts != "": - retval += " --opts=\"%s\"" % self.moduleOpts - - return retval + "\n" - -class FC3_Device(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.type = kwargs.get("type", "") - self.moduleName = kwargs.get("moduleName", "") - self.moduleOpts = kwargs.get("moduleOpts", "") - - def __eq__(self, y): - return self.moduleName == y.moduleName - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.moduleName != "": - retval += "device %s %s" % (self.type, self.moduleName) - - if self.moduleOpts != "": - retval += " --opts=\"%s\"" % self.moduleOpts - - return retval + "\n" - - def _getParser(self): - op = KSOptionParser() - op.add_option("--opts", dest="moduleOpts", default="") - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - - if len(extra) != 2: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("device command requires two arguments: module type and name")) - - self.moduleOpts = opts.moduleOpts - self.type = extra[0] - self.moduleName = extra[1] - return self - -class F8_Device(FC3_Device): - removedKeywords = FC3_Device.removedKeywords - removedAttrs = FC3_Device.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - FC3_Device.__init__(self, writePriority, *args, **kwargs) - self.deviceList = kwargs.get("deviceList", []) - - def __str__(self): - retval = "" - for device in self.deviceList: - retval += device.__str__() - - return retval - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - - if len(extra) != 1: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("%s command requires a single argument: %s") % ("device", "module name")) - - dd = F8_DeviceData() - self._setToObj(self.op, opts, dd) - dd.lineno = self.lineno - dd.moduleName = extra[0] - - # Check for duplicates in the data list. - if dd in self.dataList(): - warnings.warn(_("A module with the name %s has already been defined.") % dd.moduleName) - - return dd - - def dataList(self): - return self.deviceList diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/deviceprobe.py b/scripts/lib/mic/3rdparty/pykickstart/commands/deviceprobe.py deleted file mode 100644 index 9f462fdff7..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/deviceprobe.py +++ /dev/null @@ -1,40 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * - -class FC3_DeviceProbe(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.deviceprobe = kwargs.get("deviceprobe", "") - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.deviceprobe != "": - retval += "deviceprobe %s\n" % self.deviceprobe - - return retval - - def parse(self, args): - self.deviceprobe = " ".join(args) - return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/displaymode.py b/scripts/lib/mic/3rdparty/pykickstart/commands/displaymode.py deleted file mode 100644 index 6a12d58ec2..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/displaymode.py +++ /dev/null @@ -1,68 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.constants import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC3_DisplayMode(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - self.displayMode = kwargs.get("displayMode", None) - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.displayMode is None: - return retval - - if self.displayMode == DISPLAY_MODE_CMDLINE: - retval += "cmdline\n" - elif self.displayMode == DISPLAY_MODE_GRAPHICAL: - retval += "# Use graphical install\ngraphical\n" - elif self.displayMode == DISPLAY_MODE_TEXT: - retval += "# Use text mode install\ntext\n" - - return retval - - def _getParser(self): - op = KSOptionParser() - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - - if len(extra) > 0: - raise KickstartParseError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s does not take any arguments") % self.currentCmd) - - if self.currentCmd == "cmdline": - self.displayMode = DISPLAY_MODE_CMDLINE - elif self.currentCmd == "graphical": - self.displayMode = DISPLAY_MODE_GRAPHICAL - elif self.currentCmd == "text": - self.displayMode = DISPLAY_MODE_TEXT - - return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/dmraid.py b/scripts/lib/mic/3rdparty/pykickstart/commands/dmraid.py deleted file mode 100644 index 993575a041..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/dmraid.py +++ /dev/null @@ -1,91 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# Peter Jones <pjones@redhat.com> -# -# Copyright 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -import warnings -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC6_DmRaidData(BaseData): - removedKeywords = BaseData.removedKeywords - removedAttrs = BaseData.removedAttrs - - def __init__(self, *args, **kwargs): - BaseData.__init__(self, *args, **kwargs) - - self.name = kwargs.get("name", "") - self.devices = kwargs.get("devices", []) - self.dmset = kwargs.get("dmset", None) - - def __eq__(self, y): - return self.name == y.name and self.devices == y.devices - - def __str__(self): - retval = BaseData.__str__(self) - retval += "dmraid --name=%s" % self.name - - for dev in self.devices: - retval += " --dev=\"%s\"" % dev - - return retval + "\n" - -class FC6_DmRaid(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=60, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.dmraids = kwargs.get("dmraids", []) - - def __str__(self): - retval = "" - for dm in self.dmraids: - retval += dm.__str__() - - return retval - - def _getParser(self): - op = KSOptionParser() - op.add_option("--name", dest="name", action="store", type="string", - required=1) - op.add_option("--dev", dest="devices", action="append", type="string", - required=1) - return op - - def parse(self, args): - dm = FC6_DmRaidData() - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - dm.name = dm.name.split('/')[-1] - self._setToObj(self.op, opts, dm) - dm.lineno = self.lineno - - # Check for duplicates in the data list. - if dm in self.dataList(): - warnings.warn(_("A DM RAID device with the name %s and devices %s has already been defined.") % (dm.name, dm.devices)) - - return dm - - def dataList(self): - return self.dmraids diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/driverdisk.py b/scripts/lib/mic/3rdparty/pykickstart/commands/driverdisk.py deleted file mode 100644 index 82a58c0e28..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/driverdisk.py +++ /dev/null @@ -1,184 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007, 2008 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC3_DriverDiskData(BaseData): - removedKeywords = BaseData.removedKeywords - removedAttrs = BaseData.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - BaseData.__init__(self, *args, **kwargs) - - self.partition = kwargs.get("partition", "") - self.source = kwargs.get("source", "") - self.type = kwargs.get("type", "") - - def _getArgsAsStr(self): - retval = "" - - if self.partition: - retval += "%s" % self.partition - - if hasattr(self, "type") and self.type: - retval += " --type=%s" % self.type - elif self.source: - retval += "--source=%s" % self.source - return retval - - def __str__(self): - retval = BaseData.__str__(self) - retval += "driverdisk %s\n" % self._getArgsAsStr() - return retval - -class FC4_DriverDiskData(FC3_DriverDiskData): - removedKeywords = FC3_DriverDiskData.removedKeywords - removedAttrs = FC3_DriverDiskData.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - FC3_DriverDiskData.__init__(self, *args, **kwargs) - self.deleteRemovedAttrs() - - self.biospart = kwargs.get("biospart", "") - - def _getArgsAsStr(self): - retval = "" - - if self.partition: - retval += "%s" % self.partition - - if hasattr(self, "type") and self.type: - retval += " --type=%s" % self.type - elif self.source: - retval += "--source=%s" % self.source - elif self.biospart: - retval += "--biospart=%s" % self.biospart - - return retval - -class F12_DriverDiskData(FC4_DriverDiskData): - removedKeywords = FC4_DriverDiskData.removedKeywords + ["type"] - removedAttrs = FC4_DriverDiskData.removedAttrs + ["type"] - - def __init__(self, *args, **kwargs): - FC4_DriverDiskData.__init__(self, *args, **kwargs) - self.deleteRemovedAttrs() - -F14_DriverDiskData = F12_DriverDiskData - -class FC3_DriverDisk(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.driverdiskList = kwargs.get("driverdiskList", []) - - def __str__(self): - retval = "" - for dd in self.driverdiskList: - retval += dd.__str__() - - return retval - - def _getParser(self): - op = KSOptionParser() - op.add_option("--source") - op.add_option("--type") - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - - if len(extra) > 1: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Only one partition may be specified for driverdisk command.")) - - if len(extra) == 1 and opts.source: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Only one of --source and partition may be specified for driverdisk command.")) - - if not extra and not opts.source: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("One of --source or partition must be specified for driverdisk command.")) - - ddd = self.handler.DriverDiskData() - self._setToObj(self.op, opts, ddd) - ddd.lineno = self.lineno - if len(extra) == 1: - ddd.partition = extra[0] - - return ddd - - def dataList(self): - return self.driverdiskList - -class FC4_DriverDisk(FC3_DriverDisk): - removedKeywords = FC3_DriverDisk.removedKeywords - removedAttrs = FC3_DriverDisk.removedKeywords - - def _getParser(self): - op = FC3_DriverDisk._getParser(self) - op.add_option("--biospart") - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - - if len(extra) > 1: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Only one partition may be specified for driverdisk command.")) - - if len(extra) == 1 and opts.source: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Only one of --source and partition may be specified for driverdisk command.")) - elif len(extra) == 1 and opts.biospart: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Only one of --biospart and partition may be specified for driverdisk command.")) - elif opts.source and opts.biospart: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Only one of --biospart and --source may be specified for driverdisk command.")) - - if not extra and not opts.source and not opts.biospart: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("One of --source, --biospart, or partition must be specified for driverdisk command.")) - - ddd = self.handler.DriverDiskData() - self._setToObj(self.op, opts, ddd) - ddd.lineno = self.lineno - if len(extra) == 1: - ddd.partition = extra[0] - - return ddd - -class F12_DriverDisk(FC4_DriverDisk): - removedKeywords = FC4_DriverDisk.removedKeywords - removedAttrs = FC4_DriverDisk.removedKeywords - - def _getParser(self): - op = FC4_DriverDisk._getParser(self) - op.add_option("--type", deprecated=1) - return op - -class F14_DriverDisk(F12_DriverDisk): - removedKeywords = F12_DriverDisk.removedKeywords - removedAttrs = F12_DriverDisk.removedKeywords - - def _getParser(self): - op = F12_DriverDisk._getParser(self) - op.remove_option("--type") - return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/fcoe.py b/scripts/lib/mic/3rdparty/pykickstart/commands/fcoe.py deleted file mode 100644 index 33208499b3..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/fcoe.py +++ /dev/null @@ -1,114 +0,0 @@ -# -# Hans de Goede <hdegoede@redhat.com> -# -# Copyright 2009 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.options import * - -import gettext -import warnings -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class F12_FcoeData(BaseData): - removedKeywords = BaseData.removedKeywords - removedAttrs = BaseData.removedAttrs - - def __init__(self, *args, **kwargs): - BaseData.__init__(self, *args, **kwargs) - self.nic = kwargs.get("nic", None) - - def __eq__(self, y): - return self.nic == y.nic - - def _getArgsAsStr(self): - retval = "" - - if self.nic: - retval += " --nic=%s" % self.nic - - return retval - - def __str__(self): - retval = BaseData.__str__(self) - retval += "fcoe%s\n" % self._getArgsAsStr() - return retval - -class F13_FcoeData(F12_FcoeData): - removedKeywords = F12_FcoeData.removedKeywords - removedAttrs = F12_FcoeData.removedAttrs - - def __init__(self, *args, **kwargs): - F12_FcoeData.__init__(self, *args, **kwargs) - self.dcb = kwargs.get("dcb", False) - - def _getArgsAsStr(self): - retval = F12_FcoeData._getArgsAsStr(self) - - if self.dcb: - retval += " --dcb" - - return retval - -class F12_Fcoe(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=71, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - self.fcoe = kwargs.get("fcoe", []) - - def __str__(self): - retval = "" - for fcoe in self.fcoe: - retval += fcoe.__str__() - - return retval - - def _getParser(self): - op = KSOptionParser() - op.add_option("--nic", dest="nic", required=1) - return op - - def parse(self, args): - zd = self.handler.FcoeData() - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - if len(extra) > 0: - mapping = {"command": "fcoe", "options": extra} - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Unexpected arguments to %(command)s command: %(options)s") % mapping) - - self._setToObj(self.op, opts, zd) - zd.lineno = self.lineno - - # Check for duplicates in the data list. - if zd in self.dataList(): - warnings.warn(_("A FCOE device with the name %s has already been defined.") % zd.nic) - - return zd - - def dataList(self): - return self.fcoe - -class F13_Fcoe(F12_Fcoe): - removedKeywords = F12_Fcoe.removedKeywords - removedAttrs = F12_Fcoe.removedAttrs - - def _getParser(self): - op = F12_Fcoe._getParser(self) - op.add_option("--dcb", dest="dcb", action="store_true", default=False) - return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/firewall.py b/scripts/lib/mic/3rdparty/pykickstart/commands/firewall.py deleted file mode 100644 index 24a01bd610..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/firewall.py +++ /dev/null @@ -1,193 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC3_Firewall(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.enabled = kwargs.get("enabled", None) - self.ports = kwargs.get("ports", []) - self.trusts = kwargs.get("trusts", []) - - def __str__(self): - extra = [] - filteredPorts = [] - - retval = KickstartCommand.__str__(self) - - if self.enabled is None: - return retval - - if self.enabled: - # It's possible we have words in the ports list instead of - # port:proto (s-c-kickstart may do this). So, filter those - # out into their own list leaving what we expect. - for port in self.ports: - if port == "ssh": - extra.append(" --ssh") - elif port == "telnet": - extra.append(" --telnet") - elif port == "smtp": - extra.append(" --smtp") - elif port == "http": - extra.append(" --http") - elif port == "ftp": - extra.append(" --ftp") - else: - filteredPorts.append(port) - - # All the port:proto strings go into a comma-separated list. - portstr = ",".join(filteredPorts) - if len(portstr) > 0: - portstr = " --port=" + portstr - else: - portstr = "" - - extrastr = "".join(extra) - truststr = ",".join(self.trusts) - - if len(truststr) > 0: - truststr = " --trust=" + truststr - - # The output port list consists only of port:proto for - # everything that we don't recognize, and special options for - # those that we do. - retval += "# Firewall configuration\nfirewall --enabled%s%s%s\n" % (extrastr, portstr, truststr) - else: - retval += "# Firewall configuration\nfirewall --disabled\n" - - return retval - - def _getParser(self): - def firewall_port_cb (option, opt_str, value, parser): - for p in value.split(","): - p = p.strip() - if p.find(":") == -1: - p = "%s:tcp" % p - parser.values.ensure_value(option.dest, []).append(p) - - op = KSOptionParser(mapping={"ssh":["22:tcp"], "telnet":["23:tcp"], - "smtp":["25:tcp"], "http":["80:tcp", "443:tcp"], - "ftp":["21:tcp"]}) - - op.add_option("--disable", "--disabled", dest="enabled", - action="store_false") - op.add_option("--enable", "--enabled", dest="enabled", - action="store_true", default=True) - op.add_option("--ftp", "--http", "--smtp", "--ssh", "--telnet", - dest="ports", action="map_extend") - op.add_option("--high", deprecated=1) - op.add_option("--medium", deprecated=1) - op.add_option("--port", dest="ports", action="callback", - callback=firewall_port_cb, nargs=1, type="string") - op.add_option("--trust", dest="trusts", action="append") - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - - if len(extra) != 0: - mapping = {"command": "firewall", "options": extra} - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Unexpected arguments to %(command)s command: %(options)s") % mapping) - - self._setToSelf(self.op, opts) - return self - -class F9_Firewall(FC3_Firewall): - removedKeywords = FC3_Firewall.removedKeywords - removedAttrs = FC3_Firewall.removedAttrs - - def _getParser(self): - op = FC3_Firewall._getParser(self) - op.remove_option("--high") - op.remove_option("--medium") - return op - -class F10_Firewall(F9_Firewall): - removedKeywords = F9_Firewall.removedKeywords - removedAttrs = F9_Firewall.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - F9_Firewall.__init__(self, writePriority, *args, **kwargs) - self.services = kwargs.get("services", []) - - def __str__(self): - if self.enabled is None: - return "" - - retval = F9_Firewall.__str__(self) - if self.enabled: - retval = retval.strip() - - svcstr = ",".join(self.services) - if len(svcstr) > 0: - svcstr = " --service=" + svcstr - else: - svcstr = "" - - return retval + "%s\n" % svcstr - else: - return retval - - def _getParser(self): - def service_cb (option, opt_str, value, parser): - # python2.4 does not support action="append_const" that we were - # using for these options. Instead, we have to fake it by - # appending whatever the option string is to the service list. - if not value: - parser.values.ensure_value(option.dest, []).append(opt_str[2:]) - return - - for p in value.split(","): - p = p.strip() - parser.values.ensure_value(option.dest, []).append(p) - - op = F9_Firewall._getParser(self) - op.add_option("--service", dest="services", action="callback", - callback=service_cb, nargs=1, type="string") - op.add_option("--ftp", dest="services", action="callback", - callback=service_cb) - op.add_option("--http", dest="services", action="callback", - callback=service_cb) - op.add_option("--smtp", dest="services", action="callback", - callback=service_cb) - op.add_option("--ssh", dest="services", action="callback", - callback=service_cb) - op.add_option("--telnet", deprecated=1) - return op - -class F14_Firewall(F10_Firewall): - removedKeywords = F10_Firewall.removedKeywords + ["telnet"] - removedAttrs = F10_Firewall.removedAttrs + ["telnet"] - - def _getParser(self): - op = F10_Firewall._getParser(self) - op.remove_option("--telnet") - return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/firstboot.py b/scripts/lib/mic/3rdparty/pykickstart/commands/firstboot.py deleted file mode 100644 index 05c0ac11c6..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/firstboot.py +++ /dev/null @@ -1,62 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.constants import * -from pykickstart.options import * - -class FC3_Firstboot(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.firstboot = kwargs.get("firstboot", None) - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.firstboot is None: - return retval - - if self.firstboot == FIRSTBOOT_SKIP: - retval += "firstboot --disable\n" - elif self.firstboot == FIRSTBOOT_DEFAULT: - retval += "# Run the Setup Agent on first boot\nfirstboot --enable\n" - elif self.firstboot == FIRSTBOOT_RECONFIG: - retval += "# Run the Setup Agent on first boot\nfirstboot --reconfig\n" - - return retval - - def _getParser(self): - op = KSOptionParser() - op.add_option("--disable", "--disabled", dest="firstboot", - action="store_const", const=FIRSTBOOT_SKIP) - op.add_option("--enable", "--enabled", dest="firstboot", - action="store_const", const=FIRSTBOOT_DEFAULT) - op.add_option("--reconfig", dest="firstboot", action="store_const", - const=FIRSTBOOT_RECONFIG) - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - self.firstboot = opts.firstboot - return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/group.py b/scripts/lib/mic/3rdparty/pykickstart/commands/group.py deleted file mode 100644 index 80ba5bdca6..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/group.py +++ /dev/null @@ -1,88 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2009 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.constants import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -import warnings -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class F12_GroupData(BaseData): - removedKeywords = BaseData.removedKeywords - removedAttrs = BaseData.removedAttrs - - def __init__(self, *args, **kwargs): - BaseData.__init__(self, *args, **kwargs) - self.name = kwargs.get("name", "") - self.gid = kwargs.get("gid", None) - - def __eq__(self, y): - return self.name == y.name - - def __str__(self): - retval = BaseData.__str__(self) - retval += "group" - - if self.name: - retval += " --name=%s" % self.name - if self.gid: - retval += " --gid=%s" % self.gid - - return retval + "\n" - -class F12_Group(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.groupList = kwargs.get("groupList", []) - - def __str__(self): - retval = "" - for user in self.groupList: - retval += user.__str__() - - return retval - - def _getParser(self): - op = KSOptionParser() - op.add_option("--name", required=1) - op.add_option("--gid", type="int") - return op - - def parse(self, args): - gd = self.handler.GroupData() - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - self._setToObj(self.op, opts, gd) - gd.lineno = self.lineno - - # Check for duplicates in the data list. - if gd in self.dataList(): - warnings.warn(_("A group with the name %s has already been defined.") % gd.name) - - return gd - - def dataList(self): - return self.groupList diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/ignoredisk.py b/scripts/lib/mic/3rdparty/pykickstart/commands/ignoredisk.py deleted file mode 100644 index 676d080836..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/ignoredisk.py +++ /dev/null @@ -1,139 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007, 2009 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC3_IgnoreDisk(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.ignoredisk = kwargs.get("ignoredisk", []) - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if len(self.ignoredisk) > 0: - retval += "ignoredisk --drives=%s\n" % ",".join(self.ignoredisk) - - return retval - - def _getParser(self): - def drive_cb (option, opt_str, value, parser): - for d in value.split(','): - parser.values.ensure_value(option.dest, []).append(d) - - op = KSOptionParser() - op.add_option("--drives", dest="ignoredisk", action="callback", - callback=drive_cb, nargs=1, type="string", required=1) - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - self._setToSelf(self.op, opts) - return self - -class F8_IgnoreDisk(FC3_IgnoreDisk): - removedKeywords = FC3_IgnoreDisk.removedKeywords - removedAttrs = FC3_IgnoreDisk.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - FC3_IgnoreDisk.__init__(self, writePriority, *args, **kwargs) - - self.onlyuse = kwargs.get("onlyuse", []) - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if len(self.ignoredisk) > 0: - retval += "ignoredisk --drives=%s\n" % ",".join(self.ignoredisk) - elif len(self.onlyuse) > 0: - retval += "ignoredisk --only-use=%s\n" % ",".join(self.onlyuse) - - return retval - - def parse(self, args, errorCheck=True): - retval = FC3_IgnoreDisk.parse(self, args) - - if errorCheck: - if (len(self.ignoredisk) == 0 and len(self.onlyuse) == 0) or (len(self.ignoredisk) > 0 and (len(self.onlyuse) > 0)): - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("One of --drives or --only-use must be specified for ignoredisk command.")) - - return retval - - def _getParser(self): - def drive_cb (option, opt_str, value, parser): - for d in value.split(','): - parser.values.ensure_value(option.dest, []).append(d) - - op = FC3_IgnoreDisk._getParser(self) - op.add_option("--drives", dest="ignoredisk", action="callback", - callback=drive_cb, nargs=1, type="string") - op.add_option("--only-use", dest="onlyuse", action="callback", - callback=drive_cb, nargs=1, type="string") - return op - -class RHEL6_IgnoreDisk(F8_IgnoreDisk): - removedKeywords = F8_IgnoreDisk.removedKeywords - removedAttrs = F8_IgnoreDisk.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - F8_IgnoreDisk.__init__(self, writePriority, *args, **kwargs) - - self.interactive = kwargs.get("interactive", False) - if self.interactive: - self.ignoredisk = [] - - def __str__(self): - retval = F8_IgnoreDisk.__str__(self) - - if self.interactive: - retval = "ignoredisk --interactive\n" - - return retval - - def parse(self, args): - retval = F8_IgnoreDisk.parse(self, args, errorCheck=False) - - howmany = 0 - if len(self.ignoredisk) > 0: - howmany += 1 - if len(self.onlyuse) > 0: - howmany += 1 - if self.interactive: - howmany += 1 - if howmany != 1: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("One of --drives , --only-use , or --interactive must be specified for ignoredisk command.")) - - return retval - - def _getParser(self): - op = F8_IgnoreDisk._getParser(self) - op.add_option("--interactive", dest="interactive", action="store_true", - default=False) - return op - -F14_IgnoreDisk = RHEL6_IgnoreDisk diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/interactive.py b/scripts/lib/mic/3rdparty/pykickstart/commands/interactive.py deleted file mode 100644 index fa3dc025b1..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/interactive.py +++ /dev/null @@ -1,58 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC3_Interactive(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - self.interactive = kwargs.get("interactive", False) - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.interactive: - retval += "# Use interactive kickstart installation method\ninteractive\n" - - return retval - - def _getParser(self): - op = KSOptionParser() - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - if len(extra) > 0: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s does not take any arguments") % "interactive") - - self.interactive = True - return self - -class F14_Interactive(DeprecatedCommand): - def __init__(self): - DeprecatedCommand.__init__(self) diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/iscsi.py b/scripts/lib/mic/3rdparty/pykickstart/commands/iscsi.py deleted file mode 100644 index da5a544e86..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/iscsi.py +++ /dev/null @@ -1,133 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# Peter Jones <pjones@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC6_IscsiData(BaseData): - removedKeywords = BaseData.removedKeywords - removedAttrs = BaseData.removedAttrs - - def __init__(self, *args, **kwargs): - BaseData.__init__(self, *args, **kwargs) - self.ipaddr = kwargs.get("ipaddr", "") - self.port = kwargs.get("port", "3260") - self.target = kwargs.get("target", "") - self.user = kwargs.get("user", None) - self.password = kwargs.get("password", None) - - def _getArgsAsStr(self): - retval = "" - - if self.target != "": - retval += " --target=%s" % self.target - if self.ipaddr != "": - retval += " --ipaddr=%s" % self.ipaddr - if self.port != "3260": - retval += " --port=%s" % self.port - if self.user is not None: - retval += " --user=%s" % self.user - if self.password is not None: - retval += " --password=%s" % self.password - - return retval - - def __str__(self): - retval = BaseData.__str__(self) - retval += "iscsi%s\n" % self._getArgsAsStr() - return retval - -class F10_IscsiData(FC6_IscsiData): - removedKeywords = FC6_IscsiData.removedKeywords - removedAttrs = FC6_IscsiData.removedAttrs - - def __init__(self, *args, **kwargs): - FC6_IscsiData.__init__(self, *args, **kwargs) - self.user_in = kwargs.get("user_in", None) - self.password_in = kwargs.get("password_in", None) - - def _getArgsAsStr(self): - retval = FC6_IscsiData._getArgsAsStr(self) - - if self.user_in is not None: - retval += " --reverse-user=%s" % self.user_in - if self.password_in is not None: - retval += " --reverse-password=%s" % self.password_in - - return retval - -class FC6_Iscsi(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=71, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.iscsi = kwargs.get("iscsi", []) - - def __str__(self): - retval = "" - for iscsi in self.iscsi: - retval += iscsi.__str__() - - return retval - - def _getParser(self): - op = KSOptionParser() - op.add_option("--target", dest="target", action="store", type="string") - op.add_option("--ipaddr", dest="ipaddr", action="store", type="string", - required=1) - op.add_option("--port", dest="port", action="store", type="string") - op.add_option("--user", dest="user", action="store", type="string") - op.add_option("--password", dest="password", action="store", - type="string") - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - - if len(extra) != 0: - mapping = {"command": "iscsi", "options": extra} - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Unexpected arguments to %(command)s command: %(options)s") % mapping) - - dd = self.handler.IscsiData() - self._setToObj(self.op, opts, dd) - dd.lineno = self.lineno - return dd - - def dataList(self): - return self.iscsi - -class F10_Iscsi(FC6_Iscsi): - removedKeywords = FC6_Iscsi.removedKeywords - removedAttrs = FC6_Iscsi.removedAttrs - - def _getParser(self): - op = FC6_Iscsi._getParser(self) - op.add_option("--reverse-user", dest="user_in", action="store", - type="string") - op.add_option("--reverse-password", dest="password_in", action="store", - type="string") - return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/iscsiname.py b/scripts/lib/mic/3rdparty/pykickstart/commands/iscsiname.py deleted file mode 100644 index a87d0637d6..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/iscsiname.py +++ /dev/null @@ -1,54 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# Peter Jones <pjones@redhat.com> -# -# Copyright 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC6_IscsiName(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=70, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - self.iscsiname = kwargs.get("iscsiname", "") - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.iscsiname != "": - retval += "iscsiname %s\n" % self.iscsiname - - return retval - - def _getParser(self): - op = KSOptionParser() - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - if len(extra) != 1: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s requires one argument") % "iscsiname") - self.iscsiname = extra[0] - return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/key.py b/scripts/lib/mic/3rdparty/pykickstart/commands/key.py deleted file mode 100644 index c20c4231f6..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/key.py +++ /dev/null @@ -1,64 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.constants import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class RHEL5_Key(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - self.key = kwargs.get("key", "") - self.skip = kwargs.get("skip", False) - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.key == KS_INSTKEY_SKIP: - retval += "key --skip\n" - elif self.key != "": - retval += "key %s\n" % self.key - - return retval - - def _getParser(self): - op = KSOptionParser() - op.add_option("--skip", action="store_true", default=False) - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - self._setToSelf(self.op, opts) - - if self.skip: - self.key = KS_INSTKEY_SKIP - elif len(extra) != 1: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s requires one argument") % "key") - else: - self.key = extra[0] - - return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/keyboard.py b/scripts/lib/mic/3rdparty/pykickstart/commands/keyboard.py deleted file mode 100644 index babc2acd4c..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/keyboard.py +++ /dev/null @@ -1,55 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC3_Keyboard(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - self.keyboard = kwargs.get("keyboard", "") - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.keyboard != "": - retval += "# System keyboard\nkeyboard %s\n" % self.keyboard - - return retval - - def _getParser(self): - op = KSOptionParser() - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - - if len(extra) != 1: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s requires one argument") % "keyboard") - - self.keyboard = extra[0] - return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/lang.py b/scripts/lib/mic/3rdparty/pykickstart/commands/lang.py deleted file mode 100644 index cf5e46cda7..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/lang.py +++ /dev/null @@ -1,60 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC3_Lang(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - self.lang = kwargs.get("lang", "") - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.lang != "": - retval += "# System language\nlang %s\n" % self.lang - - return retval - - def _getParser(self): - op = KSOptionParser() - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - if len(extra) != 1: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s requires one argument") % "lang") - - self.lang = extra[0] - return self - - def apply(self, instroot="/"): - if self.lang == "": return - f = open(instroot + "/etc/sysconfig/i18n", "w+") - f.write("LANG=\"%s\"\n" %(self.lang,)) - f.close() diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/langsupport.py b/scripts/lib/mic/3rdparty/pykickstart/commands/langsupport.py deleted file mode 100644 index 73a9e537a9..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/langsupport.py +++ /dev/null @@ -1,58 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.options import * - -class FC3_LangSupport(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.deflang = kwargs.get("deflang", "") - self.supported = kwargs.get("supported", []) - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.deflang: - retval += "langsupport --default=%s" % self.deflang - - if self.supported: - retval += " %s" % " ".join(self.supported) - - return retval + "\n" - - def _getParser(self): - op = KSOptionParser() - op.add_option("--default", dest="deflang", default="en_US.UTF-8") - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - self._setToSelf(self.op, opts) - self.supported = extra - return self - -class FC5_LangSupport(DeprecatedCommand): - def __init__(self): - DeprecatedCommand.__init__(self) diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/lilocheck.py b/scripts/lib/mic/3rdparty/pykickstart/commands/lilocheck.py deleted file mode 100644 index 92b3f930b6..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/lilocheck.py +++ /dev/null @@ -1,54 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC3_LiloCheck(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - self.check = kwargs.get("check", False) - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.check: - retval += "lilocheck\n" - - return retval - - def _getParser(self): - op = KSOptionParser() - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - if len(extra) > 0: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s does not take any arguments") % "lilocheck") - - self.check = True - return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/logging.py b/scripts/lib/mic/3rdparty/pykickstart/commands/logging.py deleted file mode 100644 index 698561994d..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/logging.py +++ /dev/null @@ -1,66 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2007, 2009 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC6_Logging(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.host = kwargs.get("host", "") - self.level = kwargs.get("level", "info") - self.port = kwargs.get("port", "") - - def __str__(self): - retval = KickstartCommand.__str__(self) - retval += "# Installation logging level\nlogging --level=%s" % self.level - - if self.host != "": - retval += " --host=%s" % self.host - - if self.port != "": - retval += " --port=%s" % self.port - - return retval + "\n" - - def _getParser(self): - op = KSOptionParser() - op.add_option("--host") - op.add_option("--level", type="choice", default="info", - choices=["debug", "info", "warning", "error", "critical"]) - op.add_option("--port") - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - - if opts.port and not opts.host: - raise KickstartParseError, formatErrorMsg(self.lineno, msg=_("Can't specify --port without --host.")) - - self._setToSelf(self.op, opts) - return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/logvol.py b/scripts/lib/mic/3rdparty/pykickstart/commands/logvol.py deleted file mode 100644 index c1b9cc3a61..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/logvol.py +++ /dev/null @@ -1,304 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007, 2008 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -import warnings -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC3_LogVolData(BaseData): - removedKeywords = BaseData.removedKeywords - removedAttrs = BaseData.removedAttrs - - def __init__(self, *args, **kwargs): - BaseData.__init__(self, *args, **kwargs) - self.fstype = kwargs.get("fstype", "") - self.grow = kwargs.get("grow", False) - self.maxSizeMB = kwargs.get("maxSizeMB", 0) - self.name = kwargs.get("name", "") - self.format = kwargs.get("format", True) - self.percent = kwargs.get("percent", 0) - self.recommended = kwargs.get("recommended", False) - self.size = kwargs.get("size", None) - self.preexist = kwargs.get("preexist", False) - self.vgname = kwargs.get("vgname", "") - self.mountpoint = kwargs.get("mountpoint", "") - - def __eq__(self, y): - return self.vgname == y.vgname and self.name == y.name - - def _getArgsAsStr(self): - retval = "" - - if self.fstype != "": - retval += " --fstype=\"%s\"" % self.fstype - if self.grow: - retval += " --grow" - if self.maxSizeMB > 0: - retval += " --maxsize=%d" % self.maxSizeMB - if not self.format: - retval += " --noformat" - if self.percent > 0: - retval += " --percent=%d" % self.percent - if self.recommended: - retval += " --recommended" - if self.size > 0: - retval += " --size=%d" % self.size - if self.preexist: - retval += " --useexisting" - - return retval - - def __str__(self): - retval = BaseData.__str__(self) - retval += "logvol %s %s --name=%s --vgname=%s\n" % (self.mountpoint, self._getArgsAsStr(), self.name, self.vgname) - return retval - -class FC4_LogVolData(FC3_LogVolData): - removedKeywords = FC3_LogVolData.removedKeywords - removedAttrs = FC3_LogVolData.removedAttrs - - def __init__(self, *args, **kwargs): - FC3_LogVolData.__init__(self, *args, **kwargs) - self.bytesPerInode = kwargs.get("bytesPerInode", 4096) - self.fsopts = kwargs.get("fsopts", "") - - def _getArgsAsStr(self): - retval = FC3_LogVolData._getArgsAsStr(self) - - if hasattr(self, "bytesPerInode") and self.bytesPerInode != 0: - retval += " --bytes-per-inode=%d" % self.bytesPerInode - if self.fsopts != "": - retval += " --fsoptions=\"%s\"" % self.fsopts - - return retval - -class RHEL5_LogVolData(FC4_LogVolData): - removedKeywords = FC4_LogVolData.removedKeywords - removedAttrs = FC4_LogVolData.removedAttrs - - def __init__(self, *args, **kwargs): - FC4_LogVolData.__init__(self, *args, **kwargs) - self.encrypted = kwargs.get("encrypted", False) - self.passphrase = kwargs.get("passphrase", "") - - def _getArgsAsStr(self): - retval = FC4_LogVolData._getArgsAsStr(self) - - if self.encrypted: - retval += " --encrypted" - - if self.passphrase != "": - retval += " --passphrase=\"%s\"" % self.passphrase - - return retval - -class F9_LogVolData(FC4_LogVolData): - removedKeywords = FC4_LogVolData.removedKeywords + ["bytesPerInode"] - removedAttrs = FC4_LogVolData.removedAttrs + ["bytesPerInode"] - - def __init__(self, *args, **kwargs): - FC4_LogVolData.__init__(self, *args, **kwargs) - self.deleteRemovedAttrs() - - self.fsopts = kwargs.get("fsopts", "") - self.fsprofile = kwargs.get("fsprofile", "") - self.encrypted = kwargs.get("encrypted", False) - self.passphrase = kwargs.get("passphrase", "") - - def _getArgsAsStr(self): - retval = FC4_LogVolData._getArgsAsStr(self) - - if self.fsprofile != "": - retval += " --fsprofile=\"%s\"" % self.fsprofile - if self.encrypted: - retval += " --encrypted" - - if self.passphrase != "": - retval += " --passphrase=\"%s\"" % self.passphrase - - return retval - -class F12_LogVolData(F9_LogVolData): - removedKeywords = F9_LogVolData.removedKeywords - removedAttrs = F9_LogVolData.removedAttrs - - def __init__(self, *args, **kwargs): - F9_LogVolData.__init__(self, *args, **kwargs) - self.deleteRemovedAttrs() - - self.escrowcert = kwargs.get("escrowcert", "") - self.backuppassphrase = kwargs.get("backuppassphrase", False) - - def _getArgsAsStr(self): - retval = F9_LogVolData._getArgsAsStr(self) - - if self.encrypted and self.escrowcert != "": - retval += " --escrowcert=\"%s\"" % self.escrowcert - - if self.backuppassphrase: - retval += " --backuppassphrase" - - return retval - -F14_LogVolData = F12_LogVolData - -class F15_LogVolData(F14_LogVolData): - removedKeywords = F14_LogVolData.removedKeywords - removedAttrs = F14_LogVolData.removedAttrs - - def __init__(self, *args, **kwargs): - F14_LogVolData.__init__(self, *args, **kwargs) - self.label = kwargs.get("label", "") - - def _getArgsAsStr(self): - retval = F14_LogVolData._getArgsAsStr(self) - - if self.label != "": - retval += " --label=\"%s\"" % self.label - - return retval - -class FC3_LogVol(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=133, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.lvList = kwargs.get("lvList", []) - - def __str__(self): - retval = "" - - for part in self.lvList: - retval += part.__str__() - - return retval - - def _getParser(self): - def lv_cb (option, opt_str, value, parser): - parser.values.format = False - parser.values.preexist = True - - op = KSOptionParser() - op.add_option("--fstype", dest="fstype") - op.add_option("--grow", dest="grow", action="store_true", - default=False) - op.add_option("--maxsize", dest="maxSizeMB", action="store", type="int", - nargs=1) - op.add_option("--name", dest="name", required=1) - op.add_option("--noformat", action="callback", callback=lv_cb, - dest="format", default=True, nargs=0) - op.add_option("--percent", dest="percent", action="store", type="int", - nargs=1) - op.add_option("--recommended", dest="recommended", action="store_true", - default=False) - op.add_option("--size", dest="size", action="store", type="int", - nargs=1) - op.add_option("--useexisting", dest="preexist", action="store_true", - default=False) - op.add_option("--vgname", dest="vgname", required=1) - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - - if len(extra) == 0: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Mount point required for %s") % "logvol") - - lvd = self.handler.LogVolData() - self._setToObj(self.op, opts, lvd) - lvd.lineno = self.lineno - lvd.mountpoint=extra[0] - - # Check for duplicates in the data list. - if lvd in self.dataList(): - warnings.warn(_("A logical volume with the name %s has already been defined in volume group %s.") % (lvd.device, lvd.vgname)) - - return lvd - - def dataList(self): - return self.lvList - -class FC4_LogVol(FC3_LogVol): - removedKeywords = FC3_LogVol.removedKeywords - removedAttrs = FC3_LogVol.removedAttrs - - def _getParser(self): - op = FC3_LogVol._getParser(self) - op.add_option("--bytes-per-inode", dest="bytesPerInode", action="store", - type="int", nargs=1) - op.add_option("--fsoptions", dest="fsopts") - return op - -class RHEL5_LogVol(FC4_LogVol): - removedKeywords = FC4_LogVol.removedKeywords - removedAttrs = FC4_LogVol.removedAttrs - - def _getParser(self): - op = FC4_LogVol._getParser(self) - op.add_option("--encrypted", action="store_true", default=False) - op.add_option("--passphrase") - return op - -class F9_LogVol(FC4_LogVol): - removedKeywords = FC4_LogVol.removedKeywords - removedAttrs = FC4_LogVol.removedAttrs - - def _getParser(self): - op = FC4_LogVol._getParser(self) - op.add_option("--bytes-per-inode", deprecated=1) - op.add_option("--fsprofile", dest="fsprofile", action="store", - type="string", nargs=1) - op.add_option("--encrypted", action="store_true", default=False) - op.add_option("--passphrase") - return op - -class F12_LogVol(F9_LogVol): - removedKeywords = F9_LogVol.removedKeywords - removedAttrs = F9_LogVol.removedAttrs - - def _getParser(self): - op = F9_LogVol._getParser(self) - op.add_option("--escrowcert") - op.add_option("--backuppassphrase", action="store_true", default=False) - return op - -class F14_LogVol(F12_LogVol): - removedKeywords = F12_LogVol.removedKeywords - removedAttrs = F12_LogVol.removedAttrs - - def _getParser(self): - op = F12_LogVol._getParser(self) - op.remove_option("--bytes-per-inode") - return op - -class F15_LogVol(F14_LogVol): - removedKeywords = F14_LogVol.removedKeywords - removedAttrs = F14_LogVol.removedAttrs - - def _getParser(self): - op = F14_LogVol._getParser(self) - op.add_option("--label") - return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/mediacheck.py b/scripts/lib/mic/3rdparty/pykickstart/commands/mediacheck.py deleted file mode 100644 index 388823a839..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/mediacheck.py +++ /dev/null @@ -1,53 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC4_MediaCheck(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - self.mediacheck = kwargs.get("mediacheck", False) - - def __str__(self): - retval = KickstartCommand.__str__(self) - if self.mediacheck: - retval += "mediacheck\n" - - return retval - - def _getParser(self): - op = KSOptionParser() - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - if len(extra) > 0: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s does not take any arguments") % "mediacheck") - - self.mediacheck = True - return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/method.py b/scripts/lib/mic/3rdparty/pykickstart/commands/method.py deleted file mode 100644 index e21064acda..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/method.py +++ /dev/null @@ -1,186 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2007, 2009 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC3_Method(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.method = kwargs.get("method", "") - - # Set all these attributes so calls to this command's __call__ - # method can set them. However we don't want to provide them as - # arguments to __init__ because method is special. - self.biospart = None - self.partition = None - self.server = None - self.dir = None - self.url = None - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.method == "cdrom": - retval += "# Use CDROM installation media\ncdrom\n" - elif self.method == "harddrive": - msg = "# Use hard drive installation media\nharddrive --dir=%s" % self.dir - - if self.biospart is not None: - retval += msg + " --biospart=%s\n" % self.biospart - else: - retval += msg + " --partition=%s\n" % self.partition - elif self.method == "nfs": - retval += "# Use NFS installation media\nnfs --server=%s --dir=%s\n" % (self.server, self.dir) - elif self.method == "url": - retval += "# Use network installation\nurl --url=\"%s\"\n" % self.url - - return retval - - def _getParser(self): - op = KSOptionParser() - - # method = "cdrom" falls through to the return - if self.currentCmd == "harddrive": - op.add_option("--biospart", dest="biospart") - op.add_option("--partition", dest="partition") - op.add_option("--dir", dest="dir", required=1) - elif self.currentCmd == "nfs": - op.add_option("--server", dest="server", required=1) - op.add_option("--dir", dest="dir", required=1) - elif self.currentCmd == "url": - op.add_option("--url", dest="url", required=1) - - return op - - def parse(self, args): - self.method = self.currentCmd - - op = self._getParser() - (opts, extra) = op.parse_args(args=args, lineno=self.lineno) - self._setToSelf(op, opts) - - if self.currentCmd == "harddrive": - if self.biospart is None and self.partition is None or \ - self.biospart is not None and self.partition is not None: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("One of biospart or partition options must be specified.")) - - return self - -class FC6_Method(FC3_Method): - removedKeywords = FC3_Method.removedKeywords - removedAttrs = FC3_Method.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - FC3_Method.__init__(self, writePriority, *args, **kwargs) - - # Same reason for this attribute as the comment in FC3_Method. - self.opts = None - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.method == "cdrom": - retval += "# Use CDROM installation media\ncdrom\n" - elif self.method == "harddrive": - msg = "# Use hard drive installation media\nharddrive --dir=%s" % self.dir - - if self.biospart is not None: - retval += msg + " --biospart=%s\n" % self.biospart - else: - retval += msg + " --partition=%s\n" % self.partition - elif self.method == "nfs": - retval += "# Use NFS installation media\nnfs --server=%s --dir=%s" % (self.server, self.dir) - if self.opts is not None: - retval += " --opts=\"%s\"" % self.opts - retval += "\n" - elif self.method == "url": - retval += "# Use network installation\nurl --url=\"%s\"\n" % self.url - - return retval - - def _getParser(self): - op = FC3_Method._getParser(self) - - if self.currentCmd == "nfs": - op.add_option("--opts", dest="opts") - - return op - -class F13_Method(FC6_Method): - removedKeywords = FC6_Method.removedKeywords - removedAttrs = FC6_Method.removedAttrs - - def __init__(self, *args, **kwargs): - FC6_Method.__init__(self, *args, **kwargs) - - # And same as all the other __init__ methods. - self.proxy = "" - - def __str__(self): - retval = FC6_Method.__str__(self) - - if self.method == "url" and self.proxy: - retval = retval.strip() - retval += " --proxy=\"%s\"\n" % self.proxy - - return retval - - def _getParser(self): - op = FC6_Method._getParser(self) - - if self.currentCmd == "url": - op.add_option("--proxy") - - return op - -class F14_Method(F13_Method): - removedKeywords = F13_Method.removedKeywords - removedAttrs = F13_Method.removedAttrs - - def __init__(self, *args, **kwargs): - F13_Method.__init__(self, *args, **kwargs) - - self.noverifyssl = False - - def __str__(self): - retval = F13_Method.__str__(self) - - if self.method == "url" and self.noverifyssl: - retval = retval.strip() - retval += " --noverifyssl\n" - - return retval - - def _getParser(self): - op = F13_Method._getParser(self) - - if self.currentCmd == "url": - op.add_option("--noverifyssl", action="store_true", default=False) - - return op - -RHEL6_Method = F14_Method diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/monitor.py b/scripts/lib/mic/3rdparty/pykickstart/commands/monitor.py deleted file mode 100644 index 8c8c2c4fc9..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/monitor.py +++ /dev/null @@ -1,106 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007, 2008 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC3_Monitor(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.hsync = kwargs.get("hsync", "") - self.monitor = kwargs.get("monitor", "") - self.vsync = kwargs.get("vsync", "") - - def __str__(self): - retval = KickstartCommand.__str__(self) - retval += "monitor" - - if self.hsync != "": - retval += " --hsync=%s" % self.hsync - if self.monitor != "": - retval += " --monitor=\"%s\"" % self.monitor - if self.vsync != "": - retval += " --vsync=%s" % self.vsync - - if retval != "monitor": - return retval + "\n" - else: - return "" - - def _getParser(self): - op = KSOptionParser() - op.add_option("--hsync") - op.add_option("--monitor") - op.add_option("--vsync") - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - - if extra: - mapping = {"cmd": "monitor", "options": extra} - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Unexpected arguments to %(cmd)s command: %(options)s") % mapping) - - self._setToSelf(self.op, opts) - return self - -class FC6_Monitor(FC3_Monitor): - removedKeywords = FC3_Monitor.removedKeywords - removedAttrs = FC3_Monitor.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - FC3_Monitor.__init__(self, writePriority, *args, **kwargs) - self.probe = kwargs.get("probe", True) - - def __str__(self): - retval = KickstartCommand.__str__(self) - retval += "monitor" - - if self.hsync != "": - retval += " --hsync=%s" % self.hsync - if self.monitor != "": - retval += " --monitor=\"%s\"" % self.monitor - if not self.probe: - retval += " --noprobe" - if self.vsync != "": - retval += " --vsync=%s" % self.vsync - - if retval != "monitor": - return retval + "\n" - else: - return "" - - def _getParser(self): - op = FC3_Monitor._getParser(self) - op.add_option("--noprobe", dest="probe", action="store_false", - default=True) - return op - -class F10_Monitor(DeprecatedCommand): - def __init__(self): - DeprecatedCommand.__init__(self) diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/mouse.py b/scripts/lib/mic/3rdparty/pykickstart/commands/mouse.py deleted file mode 100644 index c643bcedc3..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/mouse.py +++ /dev/null @@ -1,70 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class RHEL3_Mouse(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.device = kwargs.get("device", "") - self.emulthree = kwargs.get("emulthree", False) - self.mouse = kwargs.get("mouse", "") - - def __str__(self): - retval = KickstartCommand.__str__(self) - - opts = "" - if self.device: - opts += "--device=%s " % self.device - if self.emulthree: - opts += "--emulthree " - - if self.mouse: - retval += "# System mouse\nmouse %s%s\n" % (opts, self.mouse) - return retval - - def _getParser(self): - op = KSOptionParser() - op.add_option("--device", dest="device", default="") - op.add_option("--emulthree", dest="emulthree", default=False, action="store_true") - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - self._setToSelf(self.op, opts) - - if len(extra) != 1: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s requires one argument") % "mouse") - - self.mouse = extra[0] - return self - -class FC3_Mouse(DeprecatedCommand): - def __init__(self): - DeprecatedCommand.__init__(self) diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/multipath.py b/scripts/lib/mic/3rdparty/pykickstart/commands/multipath.py deleted file mode 100644 index 84ba755e68..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/multipath.py +++ /dev/null @@ -1,111 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# Peter Jones <pjones@redhat.com> -# -# Copyright 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC6_MpPathData(BaseData): - removedKeywords = BaseData.removedKeywords - removedAttrs = BaseData.removedAttrs - - def __init__(self, *args, **kwargs): - BaseData.__init__(self, *args, **kwargs) - self.mpdev = kwargs.get("mpdev", "") - self.device = kwargs.get("device", "") - self.rule = kwargs.get("rule", "") - - def __str__(self): - return " --device=%s --rule=\"%s\"" % (self.device, self.rule) - -class FC6_MultiPathData(BaseData): - removedKeywords = BaseData.removedKeywords - removedAttrs = BaseData.removedAttrs - - def __init__(self, *args, **kwargs): - BaseData.__init__(self, *args, **kwargs) - self.name = kwargs.get("name", "") - self.paths = kwargs.get("paths", []) - - def __str__(self): - retval = BaseData.__str__(self) - - for path in self.paths: - retval += "multipath --mpdev=%s %s\n" % (self.name, path.__str__()) - - return retval - -class FC6_MultiPath(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=50, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.mpaths = kwargs.get("mpaths", []) - - def __str__(self): - retval = "" - for mpath in self.mpaths: - retval += mpath.__str__() - - return retval - - def _getParser(self): - op = KSOptionParser() - op.add_option("--name", dest="name", action="store", type="string", - required=1) - op.add_option("--device", dest="device", action="store", type="string", - required=1) - op.add_option("--rule", dest="rule", action="store", type="string", - required=1) - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - dd = FC6_MpPathData() - self._setToObj(self.op, opts, dd) - dd.lineno = self.lineno - dd.mpdev = dd.mpdev.split('/')[-1] - - parent = None - for x in range(0, len(self.mpaths)): - mpath = self.mpaths[x] - for path in mpath.paths: - if path.device == dd.device: - mapping = {"device": path.device, "multipathdev": path.mpdev} - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Device '%(device)s' is already used in multipath '%(multipathdev)s'") % mapping) - if mpath.name == dd.mpdev: - parent = x - - if parent is None: - mpath = FC6_MultiPathData() - return mpath - else: - mpath = self.mpaths[parent] - - return dd - - def dataList(self): - return self.mpaths diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/network.py b/scripts/lib/mic/3rdparty/pykickstart/commands/network.py deleted file mode 100644 index 9b67f92831..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/network.py +++ /dev/null @@ -1,363 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007, 2008 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.constants import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -import warnings -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC3_NetworkData(BaseData): - removedKeywords = BaseData.removedKeywords - removedAttrs = BaseData.removedAttrs - - def __init__(self, *args, **kwargs): - BaseData.__init__(self, *args, **kwargs) - self.bootProto = kwargs.get("bootProto", BOOTPROTO_DHCP) - self.dhcpclass = kwargs.get("dhcpclass", "") - self.device = kwargs.get("device", "") - self.essid = kwargs.get("essid", "") - self.ethtool = kwargs.get("ethtool", "") - self.gateway = kwargs.get("gateway", "") - self.hostname = kwargs.get("hostname", "") - self.ip = kwargs.get("ip", "") - self.mtu = kwargs.get("mtu", "") - self.nameserver = kwargs.get("nameserver", "") - self.netmask = kwargs.get("netmask", "") - self.nodns = kwargs.get("nodns", False) - self.onboot = kwargs.get("onboot", True) - self.wepkey = kwargs.get("wepkey", "") - - def __eq__(self, y): - return self.device and self.device == y.device - - def _getArgsAsStr(self): - retval = "" - - if self.bootProto != "": - retval += " --bootproto=%s" % self.bootProto - if self.dhcpclass != "": - retval += " --dhcpclass=%s" % self.dhcpclass - if self.device != "": - retval += " --device=%s" % self.device - if self.essid != "": - retval += " --essid=\"%s\"" % self.essid - if self.ethtool != "": - retval += " --ethtool=\"%s\"" % self.ethtool - if self.gateway != "": - retval += " --gateway=%s" % self.gateway - if self.hostname != "": - retval += " --hostname=%s" % self.hostname - if self.ip != "": - retval += " --ip=%s" % self.ip - if self.mtu != "": - retval += " --mtu=%s" % self.mtu - if self.nameserver != "": - retval += " --nameserver=%s" % self.nameserver - if self.netmask != "": - retval += " --netmask=%s" % self.netmask - if self.nodns: - retval += " --nodns" - if not self.onboot: - retval += " --onboot=off" - if self.wepkey != "": - retval += " --wepkey=%s" % self.wepkey - - return retval - - def __str__(self): - retval = BaseData.__str__(self) - retval += "network %s\n" % self._getArgsAsStr() - return retval - -class FC4_NetworkData(FC3_NetworkData): - removedKeywords = FC3_NetworkData.removedKeywords - removedAttrs = FC3_NetworkData.removedAttrs - - def __init__(self, *args, **kwargs): - FC3_NetworkData.__init__(self, *args, **kwargs) - self.notksdevice = kwargs.get("notksdevice", False) - - def _getArgsAsStr(self): - retval = FC3_NetworkData._getArgsAsStr(self) - - if self.notksdevice: - retval += " --notksdevice" - - return retval - -class FC6_NetworkData(FC4_NetworkData): - removedKeywords = FC4_NetworkData.removedKeywords - removedAttrs = FC4_NetworkData.removedAttrs - - def __init__(self, *args, **kwargs): - FC4_NetworkData.__init__(self, *args, **kwargs) - self.noipv4 = kwargs.get("noipv4", False) - self.noipv6 = kwargs.get("noipv6", False) - - def _getArgsAsStr(self): - retval = FC4_NetworkData._getArgsAsStr(self) - - if self.noipv4: - retval += " --noipv4" - if self.noipv6: - retval += " --noipv6" - - return retval - -class F8_NetworkData(FC6_NetworkData): - removedKeywords = FC6_NetworkData.removedKeywords - removedAttrs = FC6_NetworkData.removedAttrs - - def __init__(self, *args, **kwargs): - FC6_NetworkData.__init__(self, *args, **kwargs) - self.ipv6 = kwargs.get("ipv6", "") - - def _getArgsAsStr(self): - retval = FC6_NetworkData._getArgsAsStr(self) - - if self.ipv6 != "": - retval += " --ipv6" % self.ipv6 - - return retval - -class F16_NetworkData(F8_NetworkData): - removedKeywords = F8_NetworkData.removedKeywords - removedAttrs = F8_NetworkData.removedAttrs - - def __init__(self, *args, **kwargs): - F8_NetworkData.__init__(self, *args, **kwargs) - self.activate = kwargs.get("activate", False) - self.nodefroute = kwargs.get("nodefroute", False) - self.wpakey = kwargs.get("wpakey", "") - - def _getArgsAsStr(self): - retval = F8_NetworkData._getArgsAsStr(self) - - if self.activate: - retval += " --activate" - if self.nodefroute: - retval += " --nodefroute" - if self.wpakey != "": - retval += "--wpakey=%s" % self.wpakey - - return retval - -class RHEL4_NetworkData(FC3_NetworkData): - removedKeywords = FC3_NetworkData.removedKeywords - removedAttrs = FC3_NetworkData.removedAttrs - - def __init__(self, *args, **kwargs): - FC3_NetworkData.__init__(self, *args, **kwargs) - self.notksdevice = kwargs.get("notksdevice", False) - - def _getArgsAsStr(self): - retval = FC3_NetworkData._getArgsAsStr(self) - - if self.notksdevice: - retval += " --notksdevice" - - return retval - -class RHEL6_NetworkData(F8_NetworkData): - removedKeywords = F8_NetworkData.removedKeywords - removedAttrs = F8_NetworkData.removedAttrs - - def __init__(self, *args, **kwargs): - F8_NetworkData.__init__(self, *args, **kwargs) - self.activate = kwargs.get("activate", False) - self.nodefroute = kwargs.get("nodefroute", False) - - def _getArgsAsStr(self): - retval = F8_NetworkData._getArgsAsStr(self) - - if self.activate: - retval += " --activate" - if self.nodefroute: - retval += " --nodefroute" - - return retval - -class FC3_Network(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.bootprotoList = [BOOTPROTO_DHCP, BOOTPROTO_BOOTP, - BOOTPROTO_STATIC] - - self.op = self._getParser() - - self.network = kwargs.get("network", []) - - def __str__(self): - retval = "" - - for nic in self.network: - retval += nic.__str__() - - if retval != "": - return "# Network information\n" + retval - else: - return "" - - def _getParser(self): - op = KSOptionParser() - op.add_option("--bootproto", dest="bootProto", - default=BOOTPROTO_DHCP, - choices=self.bootprotoList) - op.add_option("--dhcpclass", dest="dhcpclass") - op.add_option("--device", dest="device") - op.add_option("--essid", dest="essid") - op.add_option("--ethtool", dest="ethtool") - op.add_option("--gateway", dest="gateway") - op.add_option("--hostname", dest="hostname") - op.add_option("--ip", dest="ip") - op.add_option("--mtu", dest="mtu") - op.add_option("--nameserver", dest="nameserver") - op.add_option("--netmask", dest="netmask") - op.add_option("--nodns", dest="nodns", action="store_true", - default=False) - op.add_option("--onboot", dest="onboot", action="store", - type="ksboolean") - op.add_option("--wepkey", dest="wepkey") - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - nd = self.handler.NetworkData() - self._setToObj(self.op, opts, nd) - nd.lineno = self.lineno - - # Check for duplicates in the data list. - if nd in self.dataList(): - warnings.warn(_("A network device with the name %s has already been defined.") % nd.device) - - return nd - - def dataList(self): - return self.network - -class FC4_Network(FC3_Network): - removedKeywords = FC3_Network.removedKeywords - removedAttrs = FC3_Network.removedAttrs - - def _getParser(self): - op = FC3_Network._getParser(self) - op.add_option("--notksdevice", dest="notksdevice", action="store_true", - default=False) - return op - -class FC6_Network(FC4_Network): - removedKeywords = FC4_Network.removedKeywords - removedAttrs = FC4_Network.removedAttrs - - def _getParser(self): - op = FC4_Network._getParser(self) - op.add_option("--noipv4", dest="noipv4", action="store_true", - default=False) - op.add_option("--noipv6", dest="noipv6", action="store_true", - default=False) - return op - -class F8_Network(FC6_Network): - removedKeywords = FC6_Network.removedKeywords - removedAttrs = FC6_Network.removedAttrs - - def _getParser(self): - op = FC6_Network._getParser(self) - op.add_option("--ipv6", dest="ipv6") - return op - -class F9_Network(F8_Network): - removedKeywords = F8_Network.removedKeywords - removedAttrs = F8_Network.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - F8_Network.__init__(self, writePriority, *args, **kwargs) - self.bootprotoList.append(BOOTPROTO_QUERY) - - def _getParser(self): - op = F8_Network._getParser(self) - op.add_option("--bootproto", dest="bootProto", - default=BOOTPROTO_DHCP, - choices=self.bootprotoList) - return op - -class F16_Network(F9_Network): - removedKeywords = F9_Network.removedKeywords - removedAttrs = F9_Network.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - F9_Network.__init__(self, writePriority, *args, **kwargs) - self.bootprotoList.append(BOOTPROTO_IBFT) - - def _getParser(self): - op = F9_Network._getParser(self) - op.add_option("--activate", dest="activate", action="store_true", - default=False) - op.add_option("--nodefroute", dest="nodefroute", action="store_true", - default=False) - op.add_option("--wpakey", dest="wpakey", action="store", default="") - return op - -class RHEL4_Network(FC3_Network): - removedKeywords = FC3_Network.removedKeywords - removedAttrs = FC3_Network.removedAttrs - - def _getParser(self): - op = FC3_Network._getParser(self) - op.add_option("--notksdevice", dest="notksdevice", action="store_true", - default=False) - return op - -class RHEL5_Network(FC6_Network): - removedKeywords = FC6_Network.removedKeywords - removedAttrs = FC6_Network.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - FC6_Network.__init__(self, writePriority, *args, **kwargs) - self.bootprotoList.append(BOOTPROTO_QUERY) - - def _getParser(self): - op = FC6_Network._getParser(self) - op.add_option("--bootproto", dest="bootProto", - default=BOOTPROTO_DHCP, - choices=self.bootprotoList) - return op - -class RHEL6_Network(F9_Network): - removedKeywords = F9_Network.removedKeywords - removedAttrs = F9_Network.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - F9_Network.__init__(self, writePriority, *args, **kwargs) - self.bootprotoList.append(BOOTPROTO_IBFT) - - def _getParser(self): - op = F9_Network._getParser(self) - op.add_option("--activate", dest="activate", action="store_true", - default=False) - op.add_option("--nodefroute", dest="nodefroute", action="store_true", - default=False) - return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/partition.py b/scripts/lib/mic/3rdparty/pykickstart/commands/partition.py deleted file mode 100644 index e65e012d02..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/partition.py +++ /dev/null @@ -1,353 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007, 2008 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -import warnings -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC3_PartData(BaseData): - removedKeywords = BaseData.removedKeywords - removedAttrs = BaseData.removedAttrs - - def __init__(self, *args, **kwargs): - BaseData.__init__(self, *args, **kwargs) - self.active = kwargs.get("active", False) - self.primOnly = kwargs.get("primOnly", False) - self.end = kwargs.get("end", 0) - self.fstype = kwargs.get("fstype", "") - self.grow = kwargs.get("grow", False) - self.maxSizeMB = kwargs.get("maxSizeMB", 0) - self.format = kwargs.get("format", True) - self.onbiosdisk = kwargs.get("onbiosdisk", "") - self.disk = kwargs.get("disk", "") - self.onPart = kwargs.get("onPart", "") - self.recommended = kwargs.get("recommended", False) - self.size = kwargs.get("size", None) - self.start = kwargs.get("start", 0) - self.mountpoint = kwargs.get("mountpoint", "") - - def __eq__(self, y): - if self.mountpoint: - return self.mountpoint == y.mountpoint - else: - return False - - def _getArgsAsStr(self): - retval = "" - - if self.active: - retval += " --active" - if self.primOnly: - retval += " --asprimary" - if hasattr(self, "end") and self.end != 0: - retval += " --end=%s" % self.end - if self.fstype != "": - retval += " --fstype=\"%s\"" % self.fstype - if self.grow: - retval += " --grow" - if self.maxSizeMB > 0: - retval += " --maxsize=%d" % self.maxSizeMB - if not self.format: - retval += " --noformat" - if self.onbiosdisk != "": - retval += " --onbiosdisk=%s" % self.onbiosdisk - if self.disk != "": - retval += " --ondisk=%s" % self.disk - if self.onPart != "": - retval += " --onpart=%s" % self.onPart - if self.recommended: - retval += " --recommended" - if self.size and self.size != 0: - retval += " --size=%s" % self.size - if hasattr(self, "start") and self.start != 0: - retval += " --start=%s" % self.start - - return retval - - def __str__(self): - retval = BaseData.__str__(self) - if self.mountpoint: - mountpoint_str = "%s" % self.mountpoint - else: - mountpoint_str = "(No mount point)" - retval += "part %s%s\n" % (mountpoint_str, self._getArgsAsStr()) - return retval - -class FC4_PartData(FC3_PartData): - removedKeywords = FC3_PartData.removedKeywords - removedAttrs = FC3_PartData.removedAttrs - - def __init__(self, *args, **kwargs): - FC3_PartData.__init__(self, *args, **kwargs) - self.bytesPerInode = kwargs.get("bytesPerInode", 4096) - self.fsopts = kwargs.get("fsopts", "") - self.label = kwargs.get("label", "") - - def _getArgsAsStr(self): - retval = FC3_PartData._getArgsAsStr(self) - - if hasattr(self, "bytesPerInode") and self.bytesPerInode != 0: - retval += " --bytes-per-inode=%d" % self.bytesPerInode - if self.fsopts != "": - retval += " --fsoptions=\"%s\"" % self.fsopts - if self.label != "": - retval += " --label=%s" % self.label - - return retval - -class RHEL5_PartData(FC4_PartData): - removedKeywords = FC4_PartData.removedKeywords - removedAttrs = FC4_PartData.removedAttrs - - def __init__(self, *args, **kwargs): - FC4_PartData.__init__(self, *args, **kwargs) - self.encrypted = kwargs.get("encrypted", False) - self.passphrase = kwargs.get("passphrase", "") - - def _getArgsAsStr(self): - retval = FC4_PartData._getArgsAsStr(self) - - if self.encrypted: - retval += " --encrypted" - - if self.passphrase != "": - retval += " --passphrase=\"%s\"" % self.passphrase - - return retval - -class F9_PartData(FC4_PartData): - removedKeywords = FC4_PartData.removedKeywords + ["bytesPerInode"] - removedAttrs = FC4_PartData.removedAttrs + ["bytesPerInode"] - - def __init__(self, *args, **kwargs): - FC4_PartData.__init__(self, *args, **kwargs) - self.deleteRemovedAttrs() - - self.fsopts = kwargs.get("fsopts", "") - self.label = kwargs.get("label", "") - self.fsprofile = kwargs.get("fsprofile", "") - self.encrypted = kwargs.get("encrypted", False) - self.passphrase = kwargs.get("passphrase", "") - - def _getArgsAsStr(self): - retval = FC4_PartData._getArgsAsStr(self) - - if self.fsprofile != "": - retval += " --fsprofile=\"%s\"" % self.fsprofile - if self.encrypted: - retval += " --encrypted" - - if self.passphrase != "": - retval += " --passphrase=\"%s\"" % self.passphrase - - return retval - -class F11_PartData(F9_PartData): - removedKeywords = F9_PartData.removedKeywords + ["start", "end"] - removedAttrs = F9_PartData.removedAttrs + ["start", "end"] - -class F12_PartData(F11_PartData): - removedKeywords = F11_PartData.removedKeywords - removedAttrs = F11_PartData.removedAttrs - - def __init__(self, *args, **kwargs): - F11_PartData.__init__(self, *args, **kwargs) - - self.escrowcert = kwargs.get("escrowcert", "") - self.backuppassphrase = kwargs.get("backuppassphrase", False) - - def _getArgsAsStr(self): - retval = F11_PartData._getArgsAsStr(self) - - if self.encrypted and self.escrowcert != "": - retval += " --escrowcert=\"%s\"" % self.escrowcert - - if self.backuppassphrase: - retval += " --backuppassphrase" - - return retval - -F14_PartData = F12_PartData - -class FC3_Partition(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=130, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.partitions = kwargs.get("partitions", []) - - def __str__(self): - retval = "" - - for part in self.partitions: - retval += part.__str__() - - if retval != "": - return "# Disk partitioning information\n" + retval - else: - return "" - - def _getParser(self): - def part_cb (option, opt_str, value, parser): - if value.startswith("/dev/"): - parser.values.ensure_value(option.dest, value[5:]) - else: - parser.values.ensure_value(option.dest, value) - - op = KSOptionParser() - op.add_option("--active", dest="active", action="store_true", - default=False) - op.add_option("--asprimary", dest="primOnly", action="store_true", - default=False) - op.add_option("--end", dest="end", action="store", type="int", - nargs=1) - op.add_option("--fstype", "--type", dest="fstype") - op.add_option("--grow", dest="grow", action="store_true", default=False) - op.add_option("--maxsize", dest="maxSizeMB", action="store", type="int", - nargs=1) - op.add_option("--noformat", dest="format", action="store_false", - default=True) - op.add_option("--onbiosdisk", dest="onbiosdisk") - op.add_option("--ondisk", "--ondrive", dest="disk") - op.add_option("--onpart", "--usepart", dest="onPart", action="callback", - callback=part_cb, nargs=1, type="string") - op.add_option("--recommended", dest="recommended", action="store_true", - default=False) - op.add_option("--size", dest="size", action="store", type="int", - nargs=1) - op.add_option("--start", dest="start", action="store", type="int", - nargs=1) - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - - pd = self.handler.PartData() - self._setToObj(self.op, opts, pd) - pd.lineno = self.lineno - if extra: - pd.mountpoint = extra[0] - if pd in self.dataList(): - warnings.warn(_("A partition with the mountpoint %s has already been defined.") % pd.mountpoint) - else: - pd.mountpoint = None - - return pd - - def dataList(self): - return self.partitions - -class FC4_Partition(FC3_Partition): - removedKeywords = FC3_Partition.removedKeywords - removedAttrs = FC3_Partition.removedAttrs - - def __init__(self, writePriority=130, *args, **kwargs): - FC3_Partition.__init__(self, writePriority, *args, **kwargs) - - def part_cb (option, opt_str, value, parser): - if value.startswith("/dev/"): - parser.values.ensure_value(option.dest, value[5:]) - else: - parser.values.ensure_value(option.dest, value) - - def _getParser(self): - op = FC3_Partition._getParser(self) - op.add_option("--bytes-per-inode", dest="bytesPerInode", action="store", - type="int", nargs=1) - op.add_option("--fsoptions", dest="fsopts") - op.add_option("--label", dest="label") - return op - -class RHEL5_Partition(FC4_Partition): - removedKeywords = FC4_Partition.removedKeywords - removedAttrs = FC4_Partition.removedAttrs - - def __init__(self, writePriority=130, *args, **kwargs): - FC4_Partition.__init__(self, writePriority, *args, **kwargs) - - def part_cb (option, opt_str, value, parser): - if value.startswith("/dev/"): - parser.values.ensure_value(option.dest, value[5:]) - else: - parser.values.ensure_value(option.dest, value) - - def _getParser(self): - op = FC4_Partition._getParser(self) - op.add_option("--encrypted", action="store_true", default=False) - op.add_option("--passphrase") - return op - -class F9_Partition(FC4_Partition): - removedKeywords = FC4_Partition.removedKeywords - removedAttrs = FC4_Partition.removedAttrs - - def __init__(self, writePriority=130, *args, **kwargs): - FC4_Partition.__init__(self, writePriority, *args, **kwargs) - - def part_cb (option, opt_str, value, parser): - if value.startswith("/dev/"): - parser.values.ensure_value(option.dest, value[5:]) - else: - parser.values.ensure_value(option.dest, value) - - def _getParser(self): - op = FC4_Partition._getParser(self) - op.add_option("--bytes-per-inode", deprecated=1) - op.add_option("--fsprofile") - op.add_option("--encrypted", action="store_true", default=False) - op.add_option("--passphrase") - return op - -class F11_Partition(F9_Partition): - removedKeywords = F9_Partition.removedKeywords - removedAttrs = F9_Partition.removedAttrs - - def _getParser(self): - op = F9_Partition._getParser(self) - op.add_option("--start", deprecated=1) - op.add_option("--end", deprecated=1) - return op - -class F12_Partition(F11_Partition): - removedKeywords = F11_Partition.removedKeywords - removedAttrs = F11_Partition.removedAttrs - - def _getParser(self): - op = F11_Partition._getParser(self) - op.add_option("--escrowcert") - op.add_option("--backuppassphrase", action="store_true", default=False) - return op - -class F14_Partition(F12_Partition): - removedKeywords = F12_Partition.removedKeywords - removedAttrs = F12_Partition.removedAttrs - - def _getParser(self): - op = F12_Partition._getParser(self) - op.remove_option("--bytes-per-inode") - op.remove_option("--start") - op.remove_option("--end") - return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/raid.py b/scripts/lib/mic/3rdparty/pykickstart/commands/raid.py deleted file mode 100644 index 0f4c92a107..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/raid.py +++ /dev/null @@ -1,365 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007, 2008, 2011 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -import warnings -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC3_RaidData(BaseData): - removedKeywords = BaseData.removedKeywords - removedAttrs = BaseData.removedAttrs - - def __init__(self, *args, **kwargs): - BaseData.__init__(self, *args, **kwargs) - self.device = kwargs.get("device", None) - self.fstype = kwargs.get("fstype", "") - self.level = kwargs.get("level", "") - self.format = kwargs.get("format", True) - self.spares = kwargs.get("spares", 0) - self.preexist = kwargs.get("preexist", False) - self.mountpoint = kwargs.get("mountpoint", "") - self.members = kwargs.get("members", []) - - def __eq__(self, y): - return self.device == y.device - - def _getArgsAsStr(self): - retval = "" - - if self.device != "": - retval += " --device=%s" % self.device - if self.fstype != "": - retval += " --fstype=\"%s\"" % self.fstype - if self.level != "": - retval += " --level=%s" % self.level - if not self.format: - retval += " --noformat" - if self.spares != 0: - retval += " --spares=%d" % self.spares - if self.preexist: - retval += " --useexisting" - - return retval - - def __str__(self): - retval = BaseData.__str__(self) - retval += "raid %s%s %s\n" % (self.mountpoint, self._getArgsAsStr(), - " ".join(self.members)) - return retval - -class FC4_RaidData(FC3_RaidData): - removedKeywords = FC3_RaidData.removedKeywords - removedAttrs = FC3_RaidData.removedAttrs - - def __init__(self, *args, **kwargs): - FC3_RaidData.__init__(self, *args, **kwargs) - self.fsopts = kwargs.get("fsopts", "") - - def _getArgsAsStr(self): - retval = FC3_RaidData._getArgsAsStr(self) - - if self.fsopts != "": - retval += " --fsoptions=\"%s\"" % self.fsopts - - return retval - -class FC5_RaidData(FC4_RaidData): - removedKeywords = FC4_RaidData.removedKeywords - removedAttrs = FC4_RaidData.removedAttrs - - def __init__(self, *args, **kwargs): - FC4_RaidData.__init__(self, *args, **kwargs) - self.bytesPerInode = kwargs.get("bytesPerInode", 4096) - - def _getArgsAsStr(self): - retval = FC4_RaidData._getArgsAsStr(self) - - if hasattr(self, "bytesPerInode") and self.bytesPerInode != 0: - retval += " --bytes-per-inode=%d" % self.bytesPerInode - - return retval - -class RHEL5_RaidData(FC5_RaidData): - removedKeywords = FC5_RaidData.removedKeywords - removedAttrs = FC5_RaidData.removedAttrs - - def __init__(self, *args, **kwargs): - FC5_RaidData.__init__(self, *args, **kwargs) - self.encrypted = kwargs.get("encrypted", False) - self.passphrase = kwargs.get("passphrase", "") - - def _getArgsAsStr(self): - retval = FC5_RaidData._getArgsAsStr(self) - - if self.encrypted: - retval += " --encrypted" - - if self.passphrase != "": - retval += " --passphrase=\"%s\"" % self.passphrase - - return retval - -F7_RaidData = FC5_RaidData - -class F9_RaidData(FC5_RaidData): - removedKeywords = FC5_RaidData.removedKeywords + ["bytesPerInode"] - removedAttrs = FC5_RaidData.removedAttrs + ["bytesPerInode"] - - def __init__(self, *args, **kwargs): - FC5_RaidData.__init__(self, *args, **kwargs) - self.deleteRemovedAttrs() - - self.fsprofile = kwargs.get("fsprofile", "") - self.encrypted = kwargs.get("encrypted", False) - self.passphrase = kwargs.get("passphrase", "") - - def _getArgsAsStr(self): - retval = FC5_RaidData._getArgsAsStr(self) - - if self.fsprofile != "": - retval += " --fsprofile=\"%s\"" % self.fsprofile - if self.encrypted: - retval += " --encrypted" - - if self.passphrase != "": - retval += " --passphrase=\"%s\"" % self.passphrase - - return retval - -class F12_RaidData(F9_RaidData): - removedKeywords = F9_RaidData.removedKeywords - removedAttrs = F9_RaidData.removedAttrs - - def __init__(self, *args, **kwargs): - F9_RaidData.__init__(self, *args, **kwargs) - self.deleteRemovedAttrs() - - self.escrowcert = kwargs.get("escrowcert", "") - self.backuppassphrase = kwargs.get("backuppassphrase", False) - - def _getArgsAsStr(self): - retval = F9_RaidData._getArgsAsStr(self) - - if self.encrypted and self.escrowcert != "": - retval += " --escrowcert=\"%s\"" % self.escrowcert - - if self.backuppassphrase: - retval += " --backuppassphrase" - return retval - -F13_RaidData = F12_RaidData - -F14_RaidData = F13_RaidData - -class F15_RaidData(F14_RaidData): - removedKeywords = F14_RaidData.removedKeywords - removedAttrs = F14_RaidData.removedAttrs - - def __init__(self, *args, **kwargs): - F14_RaidData.__init__(self, *args, **kwargs) - self.deleteRemovedAttrs() - - self.label = kwargs.get("label", "") - - def _getArgsAsStr(self): - retval = F14_RaidData._getArgsAsStr(self) - - if self.label != "": - retval += " --label=%s" % self.label - - return retval - -class FC3_Raid(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=131, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - # A dict of all the RAID levels we support. This means that if we - # support more levels in the future, subclasses don't have to - # duplicate too much. - self.levelMap = { "RAID0": "RAID0", "0": "RAID0", - "RAID1": "RAID1", "1": "RAID1", - "RAID5": "RAID5", "5": "RAID5", - "RAID6": "RAID6", "6": "RAID6" } - - self.raidList = kwargs.get("raidList", []) - - def __str__(self): - retval = "" - - for raid in self.raidList: - retval += raid.__str__() - - return retval - - def _getParser(self): - def raid_cb (option, opt_str, value, parser): - parser.values.format = False - parser.values.preexist = True - - def device_cb (option, opt_str, value, parser): - if value[0:2] == "md": - parser.values.ensure_value(option.dest, value[2:]) - else: - parser.values.ensure_value(option.dest, value) - - def level_cb (option, opt_str, value, parser): - if self.levelMap.has_key(value): - parser.values.ensure_value(option.dest, self.levelMap[value]) - - op = KSOptionParser() - op.add_option("--device", action="callback", callback=device_cb, - dest="device", type="string", nargs=1, required=1) - op.add_option("--fstype", dest="fstype") - op.add_option("--level", dest="level", action="callback", - callback=level_cb, type="string", nargs=1) - op.add_option("--noformat", action="callback", callback=raid_cb, - dest="format", default=True, nargs=0) - op.add_option("--spares", dest="spares", action="store", type="int", - nargs=1, default=0) - op.add_option("--useexisting", dest="preexist", action="store_true", - default=False) - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - - if len(extra) == 0: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Mount point required for %s") % "raid") - if len(extra) == 1: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Partitions required for %s") % "raid") - - rd = self.handler.RaidData() - self._setToObj(self.op, opts, rd) - rd.lineno = self.lineno - - # --device can't just take an int in the callback above, because it - # could be specificed as "mdX", which causes optparse to error when - # it runs int(). - rd.device = int(rd.device) - rd.mountpoint = extra[0] - rd.members = extra[1:] - - # Check for duplicates in the data list. - if rd in self.dataList(): - warnings.warn(_("A RAID device with the name %s has already been defined.") % rd.device) - - return rd - - def dataList(self): - return self.raidList - -class FC4_Raid(FC3_Raid): - removedKeywords = FC3_Raid.removedKeywords - removedAttrs = FC3_Raid.removedAttrs - - def _getParser(self): - op = FC3_Raid._getParser(self) - op.add_option("--fsoptions", dest="fsopts") - return op - -class FC5_Raid(FC4_Raid): - removedKeywords = FC4_Raid.removedKeywords - removedAttrs = FC4_Raid.removedAttrs - - def _getParser(self): - op = FC4_Raid._getParser(self) - op.add_option("--bytes-per-inode", dest="bytesPerInode", action="store", - type="int", nargs=1) - return op - -class RHEL5_Raid(FC5_Raid): - removedKeywords = FC5_Raid.removedKeywords - removedAttrs = FC5_Raid.removedAttrs - - def __init__(self, writePriority=131, *args, **kwargs): - FC5_Raid.__init__(self, writePriority, *args, **kwargs) - - self.levelMap.update({"RAID10": "RAID10", "10": "RAID10"}) - - def _getParser(self): - op = FC5_Raid._getParser(self) - op.add_option("--encrypted", action="store_true", default=False) - op.add_option("--passphrase") - return op - -class F7_Raid(FC5_Raid): - removedKeywords = FC5_Raid.removedKeywords - removedAttrs = FC5_Raid.removedAttrs - - def __init__(self, writePriority=131, *args, **kwargs): - FC5_Raid.__init__(self, writePriority, *args, **kwargs) - - self.levelMap.update({"RAID10": "RAID10", "10": "RAID10"}) - -class F9_Raid(F7_Raid): - removedKeywords = F7_Raid.removedKeywords - removedAttrs = F7_Raid.removedAttrs - - def _getParser(self): - op = F7_Raid._getParser(self) - op.add_option("--bytes-per-inode", deprecated=1) - op.add_option("--fsprofile") - op.add_option("--encrypted", action="store_true", default=False) - op.add_option("--passphrase") - return op - -class F12_Raid(F9_Raid): - removedKeywords = F9_Raid.removedKeywords - removedAttrs = F9_Raid.removedAttrs - - def _getParser(self): - op = F9_Raid._getParser(self) - op.add_option("--escrowcert") - op.add_option("--backuppassphrase", action="store_true", default=False) - return op - -class F13_Raid(F12_Raid): - removedKeywords = F12_Raid.removedKeywords - removedAttrs = F12_Raid.removedAttrs - - def __init__(self, writePriority=131, *args, **kwargs): - F12_Raid.__init__(self, writePriority, *args, **kwargs) - - self.levelMap.update({"RAID4": "RAID4", "4": "RAID4"}) - -class F14_Raid(F13_Raid): - removedKeywords = F13_Raid.removedKeywords - removedAttrs = F13_Raid.removedAttrs - - def _getParser(self): - op = F13_Raid._getParser(self) - op.remove_option("--bytes-per-inode") - return op - -class F15_Raid(F14_Raid): - removedKeywords = F14_Raid.removedKeywords - removedAttrs = F14_Raid.removedAttrs - - def _getParser(self): - op = F14_Raid._getParser(self) - op.add_option("--label") - return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/reboot.py b/scripts/lib/mic/3rdparty/pykickstart/commands/reboot.py deleted file mode 100644 index 391af14c22..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/reboot.py +++ /dev/null @@ -1,79 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.constants import * -from pykickstart.errors import * -from pykickstart.options import * - -class FC3_Reboot(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.action = kwargs.get("action", None) - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.action == KS_REBOOT: - retval += "# Reboot after installation\nreboot\n" - elif self.action == KS_SHUTDOWN: - retval += "# Shutdown after installation\nshutdown\n" - - return retval - - def parse(self, args): - if self.currentCmd == "reboot": - self.action = KS_REBOOT - else: - self.action = KS_SHUTDOWN - - return self - -class FC6_Reboot(FC3_Reboot): - removedKeywords = FC3_Reboot.removedKeywords - removedAttrs = FC3_Reboot.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - FC3_Reboot.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.eject = kwargs.get("eject", False) - - def __str__(self): - retval = FC3_Reboot.__str__(self).rstrip() - - if self.eject: - retval += " --eject" - - return retval + "\n" - - def _getParser(self): - op = KSOptionParser() - op.add_option("--eject", dest="eject", action="store_true", - default=False) - return op - - def parse(self, args): - FC3_Reboot.parse(self, args) - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - self._setToSelf(self.op, opts) - return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/repo.py b/scripts/lib/mic/3rdparty/pykickstart/commands/repo.py deleted file mode 100644 index 543ef947c1..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/repo.py +++ /dev/null @@ -1,249 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2007, 2008, 2009 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.constants import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -import warnings -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC6_RepoData(BaseData): - removedKeywords = BaseData.removedKeywords - removedAttrs = BaseData.removedAttrs - - def __init__(self, *args, **kwargs): - BaseData.__init__(self, *args, **kwargs) - self.baseurl = kwargs.get("baseurl", "") - self.mirrorlist = kwargs.get("mirrorlist", None) - self.name = kwargs.get("name", "") - - def __eq__(self, y): - return self.name == y.name - - def _getArgsAsStr(self): - retval = "" - - if self.baseurl: - retval += "--baseurl=%s" % self.baseurl - elif self.mirrorlist: - retval += "--mirrorlist=%s" % self.mirrorlist - - return retval - - def __str__(self): - retval = BaseData.__str__(self) - retval += "repo --name=\"%s\" %s\n" % (self.name, self._getArgsAsStr()) - return retval - -class F8_RepoData(FC6_RepoData): - removedKeywords = FC6_RepoData.removedKeywords - removedAttrs = FC6_RepoData.removedAttrs - - def __init__(self, *args, **kwargs): - FC6_RepoData.__init__(self, *args, **kwargs) - self.cost = kwargs.get("cost", None) - self.includepkgs = kwargs.get("includepkgs", []) - self.excludepkgs = kwargs.get("excludepkgs", []) - - def _getArgsAsStr(self): - retval = FC6_RepoData._getArgsAsStr(self) - - if self.cost: - retval += " --cost=%s" % self.cost - if self.includepkgs: - retval += " --includepkgs=\"%s\"" % ",".join(self.includepkgs) - if self.excludepkgs: - retval += " --excludepkgs=\"%s\"" % ",".join(self.excludepkgs) - - return retval - -class F11_RepoData(F8_RepoData): - removedKeywords = F8_RepoData.removedKeywords - removedAttrs = F8_RepoData.removedAttrs - - def __init__(self, *args, **kwargs): - F8_RepoData.__init__(self, *args, **kwargs) - self.ignoregroups = kwargs.get("ignoregroups", None) - - def _getArgsAsStr(self): - retval = F8_RepoData._getArgsAsStr(self) - - if self.ignoregroups: - retval += " --ignoregroups=true" - return retval - -class F13_RepoData(F11_RepoData): - removedKeywords = F11_RepoData.removedKeywords - removedAttrs = F11_RepoData.removedAttrs - - def __init__(self, *args, **kwargs): - F11_RepoData.__init__(self, *args, **kwargs) - self.proxy = kwargs.get("proxy", "") - - def _getArgsAsStr(self): - retval = F11_RepoData._getArgsAsStr(self) - - if self.proxy: - retval += " --proxy=\"%s\"" % self.proxy - - return retval - -class F14_RepoData(F13_RepoData): - removedKeywords = F13_RepoData.removedKeywords - removedAttrs = F13_RepoData.removedAttrs - - def __init__(self, *args, **kwargs): - F13_RepoData.__init__(self, *args, **kwargs) - self.noverifyssl = kwargs.get("noverifyssl", False) - - def _getArgsAsStr(self): - retval = F13_RepoData._getArgsAsStr(self) - - if self.noverifyssl: - retval += " --noverifyssl" - - return retval - -RHEL6_RepoData = F14_RepoData - -F15_RepoData = F14_RepoData - -class FC6_Repo(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - urlRequired = True - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.repoList = kwargs.get("repoList", []) - - def __str__(self): - retval = "" - for repo in self.repoList: - retval += repo.__str__() - - return retval - - def _getParser(self): - op = KSOptionParser() - op.add_option("--name", dest="name", required=1) - op.add_option("--baseurl") - op.add_option("--mirrorlist") - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - - if len(extra) != 0: - mapping = {"command": "repo", "options": extra} - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Unexpected arguments to %(command)s command: %(options)s") % mapping) - - # This is lame, but I can't think of a better way to make sure only - # one of these two is specified. - if opts.baseurl and opts.mirrorlist: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Only one of --baseurl and --mirrorlist may be specified for repo command.")) - - if self.urlRequired and not opts.baseurl and not opts.mirrorlist: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("One of --baseurl or --mirrorlist must be specified for repo command.")) - - rd = self.handler.RepoData() - self._setToObj(self.op, opts, rd) - rd.lineno = self.lineno - - # Check for duplicates in the data list. - if rd in self.dataList(): - warnings.warn(_("A repo with the name %s has already been defined.") % rd.name) - - return rd - - def dataList(self): - return self.repoList - -class F8_Repo(FC6_Repo): - removedKeywords = FC6_Repo.removedKeywords - removedAttrs = FC6_Repo.removedAttrs - - def __str__(self): - retval = "" - for repo in self.repoList: - retval += repo.__str__() - - return retval - - def _getParser(self): - def list_cb (option, opt_str, value, parser): - for d in value.split(','): - parser.values.ensure_value(option.dest, []).append(d) - - op = FC6_Repo._getParser(self) - op.add_option("--cost", action="store", type="int") - op.add_option("--excludepkgs", action="callback", callback=list_cb, - nargs=1, type="string") - op.add_option("--includepkgs", action="callback", callback=list_cb, - nargs=1, type="string") - return op - - def methodToRepo(self): - if not self.handler.method.url: - raise KickstartError, formatErrorMsg(self.handler.method.lineno, msg=_("Method must be a url to be added to the repo list.")) - reponame = "ks-method-url" - repourl = self.handler.method.url - rd = self.handler.RepoData(name=reponame, baseurl=repourl) - return rd - -class F11_Repo(F8_Repo): - removedKeywords = F8_Repo.removedKeywords - removedAttrs = F8_Repo.removedAttrs - - def _getParser(self): - op = F8_Repo._getParser(self) - op.add_option("--ignoregroups", action="store", type="ksboolean") - return op - -class F13_Repo(F11_Repo): - removedKeywords = F11_Repo.removedKeywords - removedAttrs = F11_Repo.removedAttrs - - def _getParser(self): - op = F11_Repo._getParser(self) - op.add_option("--proxy") - return op - -class F14_Repo(F13_Repo): - removedKeywords = F13_Repo.removedKeywords - removedAttrs = F13_Repo.removedAttrs - - def _getParser(self): - op = F13_Repo._getParser(self) - op.add_option("--noverifyssl", action="store_true", default=False) - return op - -RHEL6_Repo = F14_Repo - -class F15_Repo(F14_Repo): - removedKeywords = F14_Repo.removedKeywords - removedAttrs = F14_Repo.removedAttrs - - urlRequired = False diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/rescue.py b/scripts/lib/mic/3rdparty/pykickstart/commands/rescue.py deleted file mode 100644 index 1893d4ea49..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/rescue.py +++ /dev/null @@ -1,68 +0,0 @@ -# -# Alexander Todorov <atodorov@redhat.com> -# -# Copyright 2008 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class F10_Rescue(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.rescue = False - self.nomount = kwargs.get("nomount", False) - self.romount = kwargs.get("romount", False) - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.rescue: - retval += "rescue" - - if self.nomount: - retval += " --nomount" - if self.romount: - retval += " --romount" - - retval = "# Start rescue mode\n%s\n" % retval - - return retval - - def _getParser(self): - op = KSOptionParser() - op.add_option("--nomount", dest="nomount", action="store_true", default=False) - op.add_option("--romount", dest="romount", action="store_true", default=False) - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - - if opts.nomount and opts.romount: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Only one of --nomount and --romount may be specified for rescue command.")) - - self._setToSelf(self.op, opts) - self.rescue = True - return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/rootpw.py b/scripts/lib/mic/3rdparty/pykickstart/commands/rootpw.py deleted file mode 100644 index e038b4525d..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/rootpw.py +++ /dev/null @@ -1,93 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC3_RootPw(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.isCrypted = kwargs.get("isCrypted", False) - self.password = kwargs.get("password", "") - - def _getArgsAsStr(self): - retval = "" - - if self.isCrypted: - retval += " --iscrypted" - - return retval - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.password != "": - retval += "# Root password\nrootpw%s %s\n" % (self._getArgsAsStr(), self.password) - - return retval - - def _getParser(self): - op = KSOptionParser() - op.add_option("--iscrypted", dest="isCrypted", action="store_true", - default=False) - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - self._setToSelf(self.op, opts) - - if len(extra) != 1: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("A single argument is expected for the %s command") % "rootpw") - - self.password = extra[0] - return self - -class F8_RootPw(FC3_RootPw): - removedKeywords = FC3_RootPw.removedKeywords - removedAttrs = FC3_RootPw.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - FC3_RootPw.__init__(self, writePriority, *args, **kwargs) - self.lock = kwargs.get("lock", False) - - def _getArgsAsStr(self): - retval = FC3_RootPw._getArgsAsStr(self) - - if self.lock: - retval += " --lock" - - if not self.isCrypted: - retval += " --plaintext" - - return retval - - def _getParser(self): - op = FC3_RootPw._getParser(self) - op.add_option("--lock", dest="lock", action="store_true", default=False) - op.add_option("--plaintext", dest="isCrypted", action="store_false") - return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/selinux.py b/scripts/lib/mic/3rdparty/pykickstart/commands/selinux.py deleted file mode 100644 index 9f8059c76b..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/selinux.py +++ /dev/null @@ -1,64 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.constants import * -from pykickstart.options import * - -class FC3_SELinux(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.selinux = kwargs.get("selinux", None) - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if not retval and self.selinux is None: - return "" - - retval += "# SELinux configuration\n" - - if self.selinux == SELINUX_DISABLED: - retval += "selinux --disabled\n" - elif self.selinux == SELINUX_ENFORCING: - retval += "selinux --enforcing\n" - elif self.selinux == SELINUX_PERMISSIVE: - retval += "selinux --permissive\n" - - return retval - - def _getParser(self): - op = KSOptionParser() - op.add_option("--disabled", dest="selinux", action="store_const", - const=SELINUX_DISABLED) - op.add_option("--enforcing", dest="selinux", action="store_const", - const=SELINUX_ENFORCING) - op.add_option("--permissive", dest="selinux", action="store_const", - const=SELINUX_PERMISSIVE) - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - self._setToSelf(self.op, opts) - return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/services.py b/scripts/lib/mic/3rdparty/pykickstart/commands/services.py deleted file mode 100644 index 2e0eab8007..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/services.py +++ /dev/null @@ -1,71 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC6_Services(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.disabled = kwargs.get("disabled", []) - self.enabled = kwargs.get("enabled", []) - - def __str__(self): - retval = KickstartCommand.__str__(self) - args = "" - - if len(self.disabled) > 0: - args += " --disabled=\"%s\"" % ",".join(self.disabled) - if len(self.enabled) > 0: - args += " --enabled=\"%s\"" % ",".join(self.enabled) - - if args != "": - retval += "# System services\nservices%s\n" % args - - return retval - - def _getParser(self): - def services_cb (option, opt_str, value, parser): - for d in value.split(','): - parser.values.ensure_value(option.dest, []).append(d.strip()) - - op = KSOptionParser() - op.add_option("--disabled", dest="disabled", action="callback", - callback=services_cb, nargs=1, type="string") - op.add_option("--enabled", dest="enabled", action="callback", - callback=services_cb, nargs=1, type="string") - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - self._setToSelf(self.op, opts) - - if len(self.disabled) == 0 and len(self.enabled) == 0: - raise KickstartParseError, formatErrorMsg(self.lineno, msg=_("One of --disabled or --enabled must be provided.")) - - return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/skipx.py b/scripts/lib/mic/3rdparty/pykickstart/commands/skipx.py deleted file mode 100644 index 36d1a8d5ba..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/skipx.py +++ /dev/null @@ -1,54 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC3_SkipX(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - self.skipx = kwargs.get("skipx", False) - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.skipx: - retval += "# Do not configure the X Window System\nskipx\n" - - return retval - - def _getParser(self): - op = KSOptionParser() - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - if len(extra) > 0: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s does not take any arguments") % "skipx") - - self.skipx = True - return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/sshpw.py b/scripts/lib/mic/3rdparty/pykickstart/commands/sshpw.py deleted file mode 100644 index e7867ebfb2..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/sshpw.py +++ /dev/null @@ -1,105 +0,0 @@ -# -# Peter Jones <pjones@redhat.com> -# -# Copyright 2009 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class F13_SshPwData(BaseData): - removedKeywords = BaseData.removedKeywords - removedAttrs = BaseData.removedAttrs - - def __init__(self, *args, **kwargs): - BaseData.__init__(self, *args, **kwargs) - self.username = kwargs.get("username", None) - self.isCrypted = kwargs.get("isCrypted", False) - self.password = kwargs.get("password", "") - self.lock = kwargs.get("lock", False) - - def __eq__(self, y): - return self.username == y.username - - def __str__(self): - retval = BaseData.__str__(self) - - retval += "sshpw" - retval += self._getArgsAsStr() + '\n' - - return retval - - def _getArgsAsStr(self): - retval = "" - - retval += " --username=%s" % self.username - if self.lock: - retval += " --lock" - if self.isCrypted: - retval += " --iscrypted" - else: - retval += " --plaintext" - - retval += " %s" % self.password - return retval - -class F13_SshPw(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.sshUserList = kwargs.get("sshUserList", []) - - def __str__(self): - retval = "" - for user in self.sshUserList: - retval += user.__str__() - - return retval - - def _getParser(self): - op = KSOptionParser() - op.add_option("--username", dest="username", required=True) - op.add_option("--iscrypted", dest="isCrypted", action="store_true", - default=False) - op.add_option("--plaintext", dest="isCrypted", action="store_false") - op.add_option("--lock", dest="lock", action="store_true", default=False) - return op - - def parse(self, args): - ud = self.handler.SshPwData() - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - self._setToObj(self.op, opts, ud) - ud.lineno = self.lineno - - if len(extra) != 1: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("A single argument is expected for the %s command") % "sshpw") - ud.password = extra[0] - - if ud in self.dataList(): - warnings.warn(_("An ssh user with the name %s has already been defined.") % ud.name) - - return ud - - def dataList(self): - return self.sshUserList diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/timezone.py b/scripts/lib/mic/3rdparty/pykickstart/commands/timezone.py deleted file mode 100644 index f5441de593..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/timezone.py +++ /dev/null @@ -1,86 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC3_Timezone(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.isUtc = kwargs.get("isUtc", False) - self.timezone = kwargs.get("timezone", "") - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.timezone != "": - if self.isUtc: - utc = "--utc" - else: - utc = "" - - retval += "# System timezone\ntimezone %s %s\n" %(utc, self.timezone) - - return retval - - def _getParser(self): - op = KSOptionParser() - op.add_option("--utc", dest="isUtc", action="store_true", default=False) - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - self._setToSelf(self.op, opts) - - if len(extra) != 1: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("A single argument is expected for the %s command") % "timezone") - - self.timezone = extra[0] - return self - -class FC6_Timezone(FC3_Timezone): - removedKeywords = FC3_Timezone.removedKeywords - removedAttrs = FC3_Timezone.removedAttrs - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.timezone != "": - if self.isUtc: - utc = "--isUtc" - else: - utc = "" - - retval += "# System timezone\ntimezone %s %s\n" %(utc, self.timezone) - - return retval - - def _getParser(self): - op = FC3_Timezone._getParser(self) - op.add_option("--utc", "--isUtc", dest="isUtc", action="store_true", default=False) - return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/updates.py b/scripts/lib/mic/3rdparty/pykickstart/commands/updates.py deleted file mode 100644 index 53ec49f7b8..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/updates.py +++ /dev/null @@ -1,60 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class F7_Updates(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - self.url = kwargs.get("url", "") - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.url == "floppy": - retval += "updates\n" - elif self.url != "": - retval += "updates %s\n" % self.url - - return retval - - def _getParser(self): - op = KSOptionParser() - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - - if len(extra) > 1: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s only takes one argument") % "updates") - elif len(extra) == 0: - self.url = "floppy" - else: - self.url = extra[0] - - return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/upgrade.py b/scripts/lib/mic/3rdparty/pykickstart/commands/upgrade.py deleted file mode 100644 index a68a82d378..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/upgrade.py +++ /dev/null @@ -1,106 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC3_Upgrade(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.upgrade = kwargs.get("upgrade", None) - self.op = self._getParser() - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.upgrade is None: - return retval - - if self.upgrade: - retval += "# Upgrade existing installation\nupgrade\n" - else: - retval += "# Install OS instead of upgrade\ninstall\n" - - return retval - - def _getParser(self): - op = KSOptionParser() - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - - if len(extra) > 0: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s does not take any arguments") % "upgrade") - - if self.currentCmd == "upgrade": - self.upgrade = True - else: - self.upgrade = False - - return self - -class F11_Upgrade(FC3_Upgrade): - removedKeywords = FC3_Upgrade.removedKeywords - removedAttrs = FC3_Upgrade.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - FC3_Upgrade.__init__(self, writePriority, *args, **kwargs) - - self.op = self._getParser() - self.root_device = kwargs.get("root_device", None) - - def __str__(self): - if self.upgrade and (self.root_device is not None): - retval = KickstartCommand.__str__(self) - retval += "# Upgrade existing installation\nupgrade --root-device=%s\n" % self.root_device - else: - retval = FC3_Upgrade.__str__(self) - - return retval - - def _getParser(self): - op = KSOptionParser() - op.add_option("--root-device", dest="root_device") - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - - if len(extra) > 0: - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s does not take any arguments") % "upgrade") - - if (opts.root_device is not None) and (opts.root_device == ""): - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s does not accept empty parameter %s") % ("upgrade", "--root-device")) - else: - self.root_device = opts.root_device - - if self.currentCmd == "upgrade": - self.upgrade = True - else: - self.upgrade = False - - return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/user.py b/scripts/lib/mic/3rdparty/pykickstart/commands/user.py deleted file mode 100644 index 189dc7585f..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/user.py +++ /dev/null @@ -1,173 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.constants import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -import warnings -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC6_UserData(BaseData): - removedKeywords = BaseData.removedKeywords - removedAttrs = BaseData.removedAttrs - - def __init__(self, *args, **kwargs): - BaseData.__init__(self, *args, **kwargs) - self.groups = kwargs.get("groups", []) - self.homedir = kwargs.get("homedir", "") - self.isCrypted = kwargs.get("isCrypted", False) - self.name = kwargs.get("name", "") - self.password = kwargs.get("password", "") - self.shell = kwargs.get("shell", "") - self.uid = kwargs.get("uid", None) - - def __eq__(self, y): - return self.name == y.name - - def __str__(self): - retval = BaseData.__str__(self) - - if self.uid != "": - retval += "user" - retval += self._getArgsAsStr() + "\n" - - return retval - - def _getArgsAsStr(self): - retval = "" - - if len(self.groups) > 0: - retval += " --groups=%s" % ",".join(self.groups) - if self.homedir: - retval += " --homedir=%s" % self.homedir - if self.name: - retval += " --name=%s" % self.name - if self.password: - retval += " --password=%s" % self.password - if self.isCrypted: - retval += " --iscrypted" - if self.shell: - retval += " --shell=%s" % self.shell - if self.uid: - retval += " --uid=%s" % self.uid - - return retval - -class F8_UserData(FC6_UserData): - removedKeywords = FC6_UserData.removedKeywords - removedAttrs = FC6_UserData.removedAttrs - - def __init__(self, *args, **kwargs): - FC6_UserData.__init__(self, *args, **kwargs) - self.lock = kwargs.get("lock", False) - - def _getArgsAsStr(self): - retval = FC6_UserData._getArgsAsStr(self) - - if self.lock: - retval += " --lock" - - return retval - -class F12_UserData(F8_UserData): - removedKeywords = F8_UserData.removedKeywords - removedAttrs = F8_UserData.removedAttrs - - def __init__(self, *args, **kwargs): - F8_UserData.__init__(self, *args, **kwargs) - self.gecos = kwargs.get("gecos", "") - - def _getArgsAsStr(self): - retval = F8_UserData._getArgsAsStr(self) - - if self.gecos: - retval += " --gecos=\"%s\"" % (self.gecos,) - - return retval - -class FC6_User(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.userList = kwargs.get("userList", []) - - def __str__(self): - retval = "" - for user in self.userList: - retval += user.__str__() - - return retval - - def _getParser(self): - def groups_cb (option, opt_str, value, parser): - for d in value.split(','): - parser.values.ensure_value(option.dest, []).append(d) - - op = KSOptionParser() - op.add_option("--groups", dest="groups", action="callback", - callback=groups_cb, nargs=1, type="string") - op.add_option("--homedir") - op.add_option("--iscrypted", dest="isCrypted", action="store_true", - default=False) - op.add_option("--name", required=1) - op.add_option("--password") - op.add_option("--shell") - op.add_option("--uid", type="int") - return op - - def parse(self, args): - ud = self.handler.UserData() - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - self._setToObj(self.op, opts, ud) - ud.lineno = self.lineno - - # Check for duplicates in the data list. - if ud in self.dataList(): - warnings.warn(_("A user with the name %s has already been defined.") % ud.name) - - return ud - - def dataList(self): - return self.userList - -class F8_User(FC6_User): - removedKeywords = FC6_User.removedKeywords - removedAttrs = FC6_User.removedAttrs - - def _getParser(self): - op = FC6_User._getParser(self) - op.add_option("--lock", action="store_true", default=False) - op.add_option("--plaintext", dest="isCrypted", action="store_false") - return op - -class F12_User(F8_User): - removedKeywords = F8_User.removedKeywords - removedAttrs = F8_User.removedAttrs - - def _getParser(self): - op = F8_User._getParser(self) - op.add_option("--gecos", type="string") - return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/vnc.py b/scripts/lib/mic/3rdparty/pykickstart/commands/vnc.py deleted file mode 100644 index 200ccfba2e..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/vnc.py +++ /dev/null @@ -1,114 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -class FC3_Vnc(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.enabled = kwargs.get("enabled", False) - self.password = kwargs.get("password", "") - self.connect = kwargs.get("connect", "") - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if not self.enabled: - return retval - - retval += "vnc" - - if self.connect != "": - retval += " --connect=%s" % self.connect - if self.password != "": - retval += " --password=%s" % self.password - - return retval + "\n" - - def _getParser(self): - op = KSOptionParser() - op.add_option("--connect") - op.add_option("--password", dest="password") - return op - - def parse(self, args): - self.enabled = True - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - self._setToSelf(self.op, opts) - return self - -class FC6_Vnc(FC3_Vnc): - removedKeywords = FC3_Vnc.removedKeywords + ["connect"] - removedAttrs = FC3_Vnc.removedAttrs + ["connect"] - - def __init__(self, writePriority=0, host="", port="", *args, **kwargs): - FC3_Vnc.__init__(self, writePriority, *args, **kwargs) - self.deleteRemovedAttrs() - - self.host = kwargs.get("host", "") - self.port = kwargs.get("port", "") - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if not self.enabled: - return retval - - retval += "vnc" - - if self.host != "": - retval += " --host=%s" % self.host - - if self.port != "": - retval += " --port=%s" % self.port - if self.password != "": - retval += " --password=%s" % self.password - - return retval + "\n" - - def _getParser(self): - def connect_cb (option, opt_str, value, parser): - cargs = value.split(":") - parser.values.ensure_value("host", cargs[0]) - - if len(cargs) > 1: - parser.values.ensure_value("port", cargs[1]) - - op = FC3_Vnc._getParser(self) - op.add_option("--connect", action="callback", callback=connect_cb, - nargs=1, type="string") - op.add_option("--host", dest="host") - op.add_option("--port", dest="port") - return op - -class F9_Vnc(FC6_Vnc): - removedKeywords = FC6_Vnc.removedKeywords - removedAttrs = FC6_Vnc.removedAttrs - - def _getParser(self): - op = FC6_Vnc._getParser(self) - op.remove_option("--connect") - return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/volgroup.py b/scripts/lib/mic/3rdparty/pykickstart/commands/volgroup.py deleted file mode 100644 index 255c47f0ae..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/volgroup.py +++ /dev/null @@ -1,102 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.options import * - -import gettext -import warnings -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC3_VolGroupData(BaseData): - removedKeywords = BaseData.removedKeywords - removedAttrs = BaseData.removedAttrs - - def __init__(self, *args, **kwargs): - BaseData.__init__(self, *args, **kwargs) - self.format = kwargs.get("format", True) - self.pesize = kwargs.get("pesize", 32768) - self.preexist = kwargs.get("preexist", False) - self.vgname = kwargs.get("vgname", "") - self.physvols = kwargs.get("physvols", []) - - def __eq__(self, y): - return self.vgname == y.vgname - - def __str__(self): - retval = BaseData.__str__(self) - retval += "volgroup %s" % self.vgname - - if not self.format: - retval += " --noformat" - if self.pesize != 0: - retval += " --pesize=%d" % self.pesize - if self.preexist: - retval += " --useexisting" - - return retval + " " + " ".join(self.physvols) + "\n" - -class FC3_VolGroup(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=132, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.vgList = kwargs.get("vgList", []) - - def __str__(self): - retval = "" - for vg in self.vgList: - retval += vg.__str__() - - return retval - - def _getParser(self): - # Have to be a little more complicated to set two values. - def vg_cb (option, opt_str, value, parser): - parser.values.format = False - parser.values.preexist = True - - op = KSOptionParser() - op.add_option("--noformat", action="callback", callback=vg_cb, - dest="format", default=True, nargs=0) - op.add_option("--pesize", dest="pesize", type="int", nargs=1, - default=32768) - op.add_option("--useexisting", dest="preexist", action="store_true", - default=False) - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - vg = self.handler.VolGroupData() - self._setToObj(self.op, opts, vg) - vg.lineno = self.lineno - vg.vgname = extra[0] - vg.physvols = extra[1:] - - # Check for duplicates in the data list. - if vg in self.dataList(): - warnings.warn(_("A volgroup with the name %s has already been defined.") % vg.vgname) - - return vg - - def dataList(self): - return self.vgList diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/xconfig.py b/scripts/lib/mic/3rdparty/pykickstart/commands/xconfig.py deleted file mode 100644 index 644ee86743..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/xconfig.py +++ /dev/null @@ -1,184 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007, 2008 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC3_XConfig(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=0, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.card = kwargs.get("card", "") - self.defaultdesktop = kwargs.get("defaultdesktop", "") - self.depth = kwargs.get("depth", 0) - self.hsync = kwargs.get("hsync", "") - self.monitor = kwargs.get("monitor", "") - self.noProbe = kwargs.get("noProbe", False) - self.resolution = kwargs.get("resolution", "") - self.server = kwargs.get("server", "") - self.startX = kwargs.get("startX", False) - self.videoRam = kwargs.get("videoRam", "") - self.vsync = kwargs.get("vsync", "") - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.card != "": - retval += " --card=%s" % self.card - if self.defaultdesktop != "": - retval += " --defaultdesktop=%s" % self.defaultdesktop - if self.depth != 0: - retval += " --depth=%d" % self.depth - if self.hsync != "": - retval += " --hsync=%s" % self.hsync - if self.monitor != "": - retval += " --monitor=%s" % self.monitor - if self.noProbe: - retval += " --noprobe" - if self.resolution != "": - retval += " --resolution=%s" % self.resolution - if self.server != "": - retval += " --server=%s" % self.server - if self.startX: - retval += " --startxonboot" - if self.videoRam != "": - retval += " --videoram=%s" % self.videoRam - if self.vsync != "": - retval += " --vsync=%s" % self.vsync - - if retval != "": - retval = "# X Window System configuration information\nxconfig %s\n" % retval - - return retval - - def _getParser(self): - op = KSOptionParser() - op.add_option("--card") - op.add_option("--defaultdesktop") - op.add_option("--depth", action="store", type="int", nargs=1) - op.add_option("--hsync") - op.add_option("--monitor") - op.add_option("--noprobe", dest="noProbe", action="store_true", - default=False) - op.add_option("--resolution") - op.add_option("--server") - op.add_option("--startxonboot", dest="startX", action="store_true", - default=False) - op.add_option("--videoram", dest="videoRam") - op.add_option("--vsync") - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - if extra: - mapping = {"command": "xconfig", "options": extra} - raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Unexpected arguments to %(command)s command: %(options)s") % mapping) - - self._setToSelf(self.op, opts) - return self - -class FC6_XConfig(FC3_XConfig): - removedKeywords = FC3_XConfig.removedKeywords + ["card", "hsync", "monitor", "noProbe", "vsync"] - removedAttrs = FC3_XConfig.removedAttrs + ["card", "hsync", "monitor", "noProbe", "vsync"] - - def __init__(self, writePriority=0, *args, **kwargs): - FC3_XConfig.__init__(self, writePriority, *args, **kwargs) - self.deleteRemovedAttrs() - - self.driver = kwargs.get("driver", "") - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if hasattr(self, "driver") and self.driver != "": - retval += " --driver=%s" % self.driver - if self.defaultdesktop != "": - retval += " --defaultdesktop=%s" % self.defaultdesktop - if self.depth != 0: - retval += " --depth=%d" % self.depth - if hasattr(self, "resolution") and self.resolution != "": - retval += " --resolution=%s" % self.resolution - if self.startX: - retval += " --startxonboot" - if hasattr(self, "videoRam") and self.videoRam != "": - retval += " --videoram=%s" % self.videoRam - - if retval != "": - retval = "# X Window System configuration information\nxconfig %s\n" % retval - - return retval - - def _getParser(self): - op = FC3_XConfig._getParser(self) - op.add_option("--card", deprecated=1) - op.add_option("--driver", dest="driver") - op.add_option("--hsync", deprecated=1) - op.add_option("--monitor", deprecated=1) - op.add_option("--noprobe", deprecated=1) - op.add_option("--vsync", deprecated=1) - return op - -class F9_XConfig(FC6_XConfig): - removedKeywords = FC6_XConfig.removedKeywords - removedAttrs = FC6_XConfig.removedAttrs - - def _getParser(self): - op = FC6_XConfig._getParser(self) - op.remove_option("--card") - op.remove_option("--hsync") - op.remove_option("--monitor") - op.remove_option("--noprobe") - op.remove_option("--vsync") - return op - -class F10_XConfig(F9_XConfig): - removedKeywords = F9_XConfig.removedKeywords + ["driver", "resolution", "videoRam"] - removedAttrs = F9_XConfig.removedAttrs + ["driver", "resolution", "videoRam"] - - def __init__(self, writePriority=0, *args, **kwargs): - F9_XConfig.__init__(self, writePriority, *args, **kwargs) - self.deleteRemovedAttrs() - - def _getParser(self): - op = F9_XConfig._getParser(self) - op.add_option("--driver", deprecated=1) - op.add_option("--depth", deprecated=1) - op.add_option("--resolution", deprecated=1) - op.add_option("--videoram", deprecated=1) - return op - -class F14_XConfig(F10_XConfig): - removedKeywords = F10_XConfig.removedKeywords - removedAttrs = F10_XConfig.removedAttrs - - def _getParser(self): - op = F10_XConfig._getParser(self) - op.remove_option("--driver") - op.remove_option("--depth") - op.remove_option("--resolution") - op.remove_option("--videoram") - return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/zerombr.py b/scripts/lib/mic/3rdparty/pykickstart/commands/zerombr.py deleted file mode 100644 index 79555a9b27..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/zerombr.py +++ /dev/null @@ -1,69 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -import warnings - -from pykickstart.base import * -from pykickstart.options import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC3_ZeroMbr(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=110, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - self.zerombr = kwargs.get("zerombr", False) - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.zerombr: - retval += "# Clear the Master Boot Record\nzerombr\n" - - return retval - - def _getParser(self): - op = KSOptionParser() - return op - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - - if len(extra) > 0: - warnings.warn(_("Ignoring deprecated option on line %s: The zerombr command no longer takes any options. In future releases, this will result in a fatal error from kickstart. Please modify your kickstart file to remove any options.") % self.lineno, DeprecationWarning) - - self.zerombr = True - return self - -class F9_ZeroMbr(FC3_ZeroMbr): - removedKeywords = FC3_ZeroMbr.removedKeywords - removedAttrs = FC3_ZeroMbr.removedAttrs - - def parse(self, args): - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - - if len(extra) > 0: - raise KickstartParseError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s does not take any arguments") % "zerombr") - - self.zerombr = True - return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/zfcp.py b/scripts/lib/mic/3rdparty/pykickstart/commands/zfcp.py deleted file mode 100644 index 1ed2694c89..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/commands/zfcp.py +++ /dev/null @@ -1,134 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.options import * - -import gettext -import warnings -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class FC3_ZFCPData(BaseData): - removedKeywords = BaseData.removedKeywords - removedAttrs = BaseData.removedAttrs - - def __init__(self, *args, **kwargs): - BaseData.__init__(self, *args, **kwargs) - self.devnum = kwargs.get("devnum", "") - self.wwpn = kwargs.get("wwpn", "") - self.fcplun = kwargs.get("fcplun", "") - self.scsiid = kwargs.get("scsiid", "") - self.scsilun = kwargs.get("scsilun", "") - - def __eq__(self, y): - return self.devnum == y.devnum and self.wwpn == y.wwpn and \ - self.fcplun == y.fcplun and self.scsiid == y.scsiid and \ - self.scsilun == y.scsilun - - def __str__(self): - retval = BaseData.__str__(self) - retval += "zfcp" - - if self.devnum != "": - retval += " --devnum=%s" % self.devnum - if self.wwpn != "": - retval += " --wwpn=%s" % self.wwpn - if self.fcplun != "": - retval += " --fcplun=%s" % self.fcplun - if hasattr(self, "scsiid") and self.scsiid != "": - retval += " --scsiid=%s" % self.scsiid - if hasattr(self, "scsilun") and self.scsilun != "": - retval += " --scsilun=%s" % self.scsilun - - return retval + "\n" - -class F12_ZFCPData(FC3_ZFCPData): - removedKeywords = FC3_ZFCPData.removedKeywords + ["scsiid", "scsilun"] - removedAttrs = FC3_ZFCPData.removedAttrs + ["scsiid", "scsilun"] - - def __init__(self, *args, **kwargs): - FC3_ZFCPData.__init__(self, *args, **kwargs) - self.deleteRemovedAttrs() - -F14_ZFCPData = F12_ZFCPData - -class FC3_ZFCP(KickstartCommand): - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, writePriority=71, *args, **kwargs): - KickstartCommand.__init__(self, writePriority, *args, **kwargs) - self.op = self._getParser() - - self.zfcp = kwargs.get("zfcp", []) - - def __str__(self): - retval = "" - for zfcp in self.zfcp: - retval += zfcp.__str__() - - return retval - - def _getParser(self): - op = KSOptionParser() - op.add_option("--devnum", dest="devnum", required=1) - op.add_option("--fcplun", dest="fcplun", required=1) - op.add_option("--scsiid", dest="scsiid", required=1) - op.add_option("--scsilun", dest="scsilun", required=1) - op.add_option("--wwpn", dest="wwpn", required=1) - return op - - def parse(self, args): - zd = self.handler.ZFCPData() - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - self._setToObj(self.op, opts, zd) - zd.lineno = self.lineno - - # Check for duplicates in the data list. - if zd in self.dataList(): - warnings.warn(_("A zfcp with this information has already been defined.")) - - return zd - - def dataList(self): - return self.zfcp - -class F12_ZFCP(FC3_ZFCP): - removedKeywords = FC3_ZFCP.removedKeywords - removedAttrs = FC3_ZFCP.removedAttrs + ["scsiid", "scsilun"] - - def __init__(self, *args, **kwargs): - FC3_ZFCP.__init__(self, *args, **kwargs) - self.deleteRemovedAttrs() - - def _getParser(self): - op = FC3_ZFCP._getParser(self) - op.add_option("--scsiid", deprecated=1) - op.add_option("--scsilun", deprecated=1) - return op - -class F14_ZFCP(F12_ZFCP): - removedKeywords = F12_ZFCP.removedKeywords - removedAttrs = F12_ZFCP.removedAttrs - - def _getParser(self): - op = F12_ZFCP._getParser(self) - op.remove_option("--scsiid") - op.remove_option("--scsilun") - return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/constants.py b/scripts/lib/mic/3rdparty/pykickstart/constants.py deleted file mode 100644 index 5e12fc80ec..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/constants.py +++ /dev/null @@ -1,57 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005-2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -CLEARPART_TYPE_LINUX = 0 -CLEARPART_TYPE_ALL = 1 -CLEARPART_TYPE_NONE = 2 - -DISPLAY_MODE_CMDLINE = 0 -DISPLAY_MODE_GRAPHICAL = 1 -DISPLAY_MODE_TEXT = 2 - -FIRSTBOOT_DEFAULT = 0 -FIRSTBOOT_SKIP = 1 -FIRSTBOOT_RECONFIG = 2 - -KS_MISSING_PROMPT = 0 -KS_MISSING_IGNORE = 1 - -SELINUX_DISABLED = 0 -SELINUX_ENFORCING = 1 -SELINUX_PERMISSIVE = 2 - -KS_SCRIPT_PRE = 0 -KS_SCRIPT_POST = 1 -KS_SCRIPT_TRACEBACK = 2 - -KS_WAIT = 0 -KS_REBOOT = 1 -KS_SHUTDOWN = 2 - -KS_INSTKEY_SKIP = -99 - -BOOTPROTO_DHCP = "dhcp" -BOOTPROTO_BOOTP = "bootp" -BOOTPROTO_STATIC = "static" -BOOTPROTO_QUERY = "query" -BOOTPROTO_IBFT = "ibft" - -GROUP_REQUIRED = 0 -GROUP_DEFAULT = 1 -GROUP_ALL = 2 diff --git a/scripts/lib/mic/3rdparty/pykickstart/errors.py b/scripts/lib/mic/3rdparty/pykickstart/errors.py deleted file mode 100644 index a234d99d43..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/errors.py +++ /dev/null @@ -1,103 +0,0 @@ -# -# errors.py: Kickstart error handling. -# -# Chris Lumens <clumens@redhat.com> -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -""" -Error handling classes and functions. - -This module exports a single function: - - formatErrorMsg - Properly formats an error message. - -It also exports several exception classes: - - KickstartError - A generic exception class. - - KickstartParseError - An exception for errors relating to parsing. - - KickstartValueError - An exception for errors relating to option - processing. - - KickstartVersionError - An exception for errors relating to unsupported - syntax versions. -""" -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -def formatErrorMsg(lineno, msg=""): - """Properly format the error message msg for inclusion in an exception.""" - if msg != "": - mapping = {"lineno": lineno, "msg": msg} - return _("The following problem occurred on line %(lineno)s of the kickstart file:\n\n%(msg)s\n") % mapping - else: - return _("There was a problem reading from line %s of the kickstart file") % lineno - -class KickstartError(Exception): - """A generic exception class for unspecific error conditions.""" - def __init__(self, val = ""): - """Create a new KickstartError exception instance with the descriptive - message val. val should be the return value of formatErrorMsg. - """ - Exception.__init__(self) - self.value = val - - def __str__ (self): - return self.value - -class KickstartParseError(KickstartError): - """An exception class for errors when processing the input file, such as - unknown options, commands, or sections. - """ - def __init__(self, msg): - """Create a new KickstartParseError exception instance with the - descriptive message val. val should be the return value of - formatErrorMsg. - """ - KickstartError.__init__(self, msg) - - def __str__(self): - return self.value - -class KickstartValueError(KickstartError): - """An exception class for errors when processing arguments to commands, - such as too many arguments, too few arguments, or missing required - arguments. - """ - def __init__(self, msg): - """Create a new KickstartValueError exception instance with the - descriptive message val. val should be the return value of - formatErrorMsg. - """ - KickstartError.__init__(self, msg) - - def __str__ (self): - return self.value - -class KickstartVersionError(KickstartError): - """An exception class for errors related to using an incorrect version of - kickstart syntax. - """ - def __init__(self, msg): - """Create a new KickstartVersionError exception instance with the - descriptive message val. val should be the return value of - formatErrorMsg. - """ - KickstartError.__init__(self, msg) - - def __str__ (self): - return self.value diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/control.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/control.py deleted file mode 100644 index d8c8f2b899..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/handlers/control.py +++ /dev/null @@ -1,1307 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2007, 2008, 2009, 2010 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.version import * -from pykickstart.commands import * - -# This map is keyed on kickstart syntax version as provided by -# pykickstart.version. Within each sub-dict is a mapping from command name -# to the class that handles it. This is an onto mapping - that is, multiple -# command names can map to the same class. However, the Handler will ensure -# that only one instance of each class ever exists. -commandMap = { - FC3: { - "auth": authconfig.FC3_Authconfig, - "authconfig": authconfig.FC3_Authconfig, - "autopart": autopart.FC3_AutoPart, - "autostep": autostep.FC3_AutoStep, - "bootloader": bootloader.FC3_Bootloader, - "cdrom": method.FC3_Method, - "clearpart": clearpart.FC3_ClearPart, - "cmdline": displaymode.FC3_DisplayMode, - "device": device.FC3_Device, - "deviceprobe": deviceprobe.FC3_DeviceProbe, - "driverdisk": driverdisk.FC3_DriverDisk, - "firewall": firewall.FC3_Firewall, - "firstboot": firstboot.FC3_Firstboot, - "graphical": displaymode.FC3_DisplayMode, - "halt": reboot.FC3_Reboot, - "harddrive": method.FC3_Method, - "ignoredisk": ignoredisk.FC3_IgnoreDisk, - "install": upgrade.FC3_Upgrade, - "interactive": interactive.FC3_Interactive, - "keyboard": keyboard.FC3_Keyboard, - "lang": lang.FC3_Lang, - "langsupport": langsupport.FC3_LangSupport, - "lilo": bootloader.FC3_Bootloader, - "lilocheck": lilocheck.FC3_LiloCheck, - "logvol": logvol.FC3_LogVol, - "monitor": monitor.FC3_Monitor, - "mouse": mouse.FC3_Mouse, - "network": network.FC3_Network, - "nfs": method.FC3_Method, - "part": partition.FC3_Partition, - "partition": partition.FC3_Partition, - "poweroff": reboot.FC3_Reboot, - "raid": raid.FC3_Raid, - "reboot": reboot.FC3_Reboot, - "rootpw": rootpw.FC3_RootPw, - "selinux": selinux.FC3_SELinux, - "shutdown": reboot.FC3_Reboot, - "skipx": skipx.FC3_SkipX, - "text": displaymode.FC3_DisplayMode, - "timezone": timezone.FC3_Timezone, - "upgrade": upgrade.FC3_Upgrade, - "url": method.FC3_Method, - "vnc": vnc.FC3_Vnc, - "volgroup": volgroup.FC3_VolGroup, - "xconfig": xconfig.FC3_XConfig, - "zerombr": zerombr.FC3_ZeroMbr, - "zfcp": zfcp.FC3_ZFCP, - }, - - # based on fc3 - FC4: { - "auth": authconfig.FC3_Authconfig, - "authconfig": authconfig.FC3_Authconfig, - "autopart": autopart.FC3_AutoPart, - "autostep": autostep.FC3_AutoStep, - "bootloader": bootloader.FC4_Bootloader, - "cdrom": method.FC3_Method, - "clearpart": clearpart.FC3_ClearPart, - "cmdline": displaymode.FC3_DisplayMode, - "device": device.FC3_Device, - "deviceprobe": deviceprobe.FC3_DeviceProbe, - "driverdisk": driverdisk.FC4_DriverDisk, - "firewall": firewall.FC3_Firewall, - "firstboot": firstboot.FC3_Firstboot, - "graphical": displaymode.FC3_DisplayMode, - "halt": reboot.FC3_Reboot, - "harddrive": method.FC3_Method, - "ignoredisk": ignoredisk.FC3_IgnoreDisk, - "install": upgrade.FC3_Upgrade, - "interactive": interactive.FC3_Interactive, - "keyboard": keyboard.FC3_Keyboard, - "lang": lang.FC3_Lang, - "langsupport": langsupport.FC3_LangSupport, - "logvol": logvol.FC4_LogVol, - "mediacheck": mediacheck.FC4_MediaCheck, - "monitor": monitor.FC3_Monitor, - "mouse": mouse.FC3_Mouse, - "network": network.FC4_Network, - "nfs": method.FC3_Method, - "part": partition.FC4_Partition, - "partition": partition.FC4_Partition, - "poweroff": reboot.FC3_Reboot, - "raid": raid.FC4_Raid, - "reboot": reboot.FC3_Reboot, - "rootpw": rootpw.FC3_RootPw, - "selinux": selinux.FC3_SELinux, - "shutdown": reboot.FC3_Reboot, - "skipx": skipx.FC3_SkipX, - "text": displaymode.FC3_DisplayMode, - "timezone": timezone.FC3_Timezone, - "upgrade": upgrade.FC3_Upgrade, - "url": method.FC3_Method, - "vnc": vnc.FC3_Vnc, - "volgroup": volgroup.FC3_VolGroup, - "xconfig": xconfig.FC3_XConfig, - "zerombr": zerombr.FC3_ZeroMbr, - "zfcp": zfcp.FC3_ZFCP, - }, - - # based on fc4 - FC5: { - "auth": authconfig.FC3_Authconfig, - "authconfig": authconfig.FC3_Authconfig, - "autopart": autopart.FC3_AutoPart, - "autostep": autostep.FC3_AutoStep, - "bootloader": bootloader.FC4_Bootloader, - "cdrom": method.FC3_Method, - "clearpart": clearpart.FC3_ClearPart, - "cmdline": displaymode.FC3_DisplayMode, - "device": device.FC3_Device, - "deviceprobe": deviceprobe.FC3_DeviceProbe, - "driverdisk": driverdisk.FC4_DriverDisk, - "firewall": firewall.FC3_Firewall, - "firstboot": firstboot.FC3_Firstboot, - "graphical": displaymode.FC3_DisplayMode, - "halt": reboot.FC3_Reboot, - "harddrive": method.FC3_Method, - "ignoredisk": ignoredisk.FC3_IgnoreDisk, - "install": upgrade.FC3_Upgrade, - "interactive": interactive.FC3_Interactive, - "keyboard": keyboard.FC3_Keyboard, - "lang": lang.FC3_Lang, - "langsupport": langsupport.FC5_LangSupport, - "logvol": logvol.FC4_LogVol, - "mediacheck": mediacheck.FC4_MediaCheck, - "monitor": monitor.FC3_Monitor, - "mouse": mouse.FC3_Mouse, - "network": network.FC4_Network, - "nfs": method.FC3_Method, - "part": partition.FC4_Partition, - "partition": partition.FC4_Partition, - "poweroff": reboot.FC3_Reboot, - "raid": raid.FC5_Raid, - "reboot": reboot.FC3_Reboot, - "rootpw": rootpw.FC3_RootPw, - "selinux": selinux.FC3_SELinux, - "shutdown": reboot.FC3_Reboot, - "skipx": skipx.FC3_SkipX, - "text": displaymode.FC3_DisplayMode, - "timezone": timezone.FC3_Timezone, - "upgrade": upgrade.FC3_Upgrade, - "url": method.FC3_Method, - "vnc": vnc.FC3_Vnc, - "volgroup": volgroup.FC3_VolGroup, - "xconfig": xconfig.FC3_XConfig, - "zerombr": zerombr.FC3_ZeroMbr, - "zfcp": zfcp.FC3_ZFCP, - }, - - # based on fc5 - FC6: { - "auth": authconfig.FC3_Authconfig, - "authconfig": authconfig.FC3_Authconfig, - "autopart": autopart.FC3_AutoPart, - "autostep": autostep.FC3_AutoStep, - "bootloader": bootloader.FC4_Bootloader, - "cdrom": method.FC6_Method, - "clearpart": clearpart.FC3_ClearPart, - "cmdline": displaymode.FC3_DisplayMode, - "device": device.FC3_Device, - "deviceprobe": deviceprobe.FC3_DeviceProbe, - "dmraid": dmraid.FC6_DmRaid, - "driverdisk": driverdisk.FC4_DriverDisk, - "firewall": firewall.FC3_Firewall, - "firstboot": firstboot.FC3_Firstboot, - "graphical": displaymode.FC3_DisplayMode, - "halt": reboot.FC6_Reboot, - "harddrive": method.FC6_Method, - "ignoredisk": ignoredisk.FC3_IgnoreDisk, - "install": upgrade.FC3_Upgrade, - "interactive": interactive.FC3_Interactive, - "iscsi": iscsi.FC6_Iscsi, - "iscsiname": iscsiname.FC6_IscsiName, - "keyboard": keyboard.FC3_Keyboard, - "lang": lang.FC3_Lang, - "langsupport": langsupport.FC5_LangSupport, - "logging": logging.FC6_Logging, - "logvol": logvol.FC4_LogVol, - "mediacheck": mediacheck.FC4_MediaCheck, - "monitor": monitor.FC6_Monitor, - "mouse": mouse.FC3_Mouse, - "multipath": multipath.FC6_MultiPath, - "network": network.FC6_Network, - "nfs": method.FC6_Method, - "part": partition.FC4_Partition, - "partition": partition.FC4_Partition, - "poweroff": reboot.FC6_Reboot, - "raid": raid.FC5_Raid, - "reboot": reboot.FC6_Reboot, - "repo": repo.FC6_Repo, - "rootpw": rootpw.FC3_RootPw, - "selinux": selinux.FC3_SELinux, - "services": services.FC6_Services, - "shutdown": reboot.FC6_Reboot, - "skipx": skipx.FC3_SkipX, - "text": displaymode.FC3_DisplayMode, - "timezone": timezone.FC6_Timezone, - "upgrade": upgrade.FC3_Upgrade, - "user": user.FC6_User, - "url": method.FC6_Method, - "vnc": vnc.FC6_Vnc, - "volgroup": volgroup.FC3_VolGroup, - "xconfig": xconfig.FC6_XConfig, - "zerombr": zerombr.FC3_ZeroMbr, - "zfcp": zfcp.FC3_ZFCP, - }, - - # based on fc6 - F7: { - "auth": authconfig.FC3_Authconfig, - "authconfig": authconfig.FC3_Authconfig, - "autopart": autopart.FC3_AutoPart, - "autostep": autostep.FC3_AutoStep, - "bootloader": bootloader.FC4_Bootloader, - "cdrom": method.FC6_Method, - "clearpart": clearpart.FC3_ClearPart, - "cmdline": displaymode.FC3_DisplayMode, - "device": device.FC3_Device, - "deviceprobe": deviceprobe.FC3_DeviceProbe, - "dmraid": dmraid.FC6_DmRaid, - "driverdisk": driverdisk.FC4_DriverDisk, - "firewall": firewall.FC3_Firewall, - "firstboot": firstboot.FC3_Firstboot, - "graphical": displaymode.FC3_DisplayMode, - "halt": reboot.FC6_Reboot, - "harddrive": method.FC6_Method, - "ignoredisk": ignoredisk.FC3_IgnoreDisk, - "install": upgrade.FC3_Upgrade, - "interactive": interactive.FC3_Interactive, - "iscsi": iscsi.FC6_Iscsi, - "iscsiname": iscsiname.FC6_IscsiName, - "keyboard": keyboard.FC3_Keyboard, - "lang": lang.FC3_Lang, - "logging": logging.FC6_Logging, - "logvol": logvol.FC4_LogVol, - "mediacheck": mediacheck.FC4_MediaCheck, - "monitor": monitor.FC6_Monitor, - "multipath": multipath.FC6_MultiPath, - "network": network.FC6_Network, - "nfs": method.FC6_Method, - "part": partition.FC4_Partition, - "partition": partition.FC4_Partition, - "poweroff": reboot.FC6_Reboot, - "raid": raid.F7_Raid, - "reboot": reboot.FC6_Reboot, - "repo": repo.FC6_Repo, - "rootpw": rootpw.FC3_RootPw, - "selinux": selinux.FC3_SELinux, - "services": services.FC6_Services, - "shutdown": reboot.FC6_Reboot, - "skipx": skipx.FC3_SkipX, - "text": displaymode.FC3_DisplayMode, - "timezone": timezone.FC6_Timezone, - "updates": updates.F7_Updates, - "upgrade": upgrade.FC3_Upgrade, - "url": method.FC6_Method, - "user": user.FC6_User, - "vnc": vnc.FC6_Vnc, - "volgroup": volgroup.FC3_VolGroup, - "xconfig": xconfig.FC6_XConfig, - "zerombr": zerombr.FC3_ZeroMbr, - "zfcp": zfcp.FC3_ZFCP, - }, - - # based on f7 - F8: { - "auth": authconfig.FC3_Authconfig, - "authconfig": authconfig.FC3_Authconfig, - "autopart": autopart.FC3_AutoPart, - "autostep": autostep.FC3_AutoStep, - "bootloader": bootloader.F8_Bootloader, - "cdrom": method.FC6_Method, - "clearpart": clearpart.FC3_ClearPart, - "cmdline": displaymode.FC3_DisplayMode, - "device": device.F8_Device, - "deviceprobe": deviceprobe.FC3_DeviceProbe, - "dmraid": dmraid.FC6_DmRaid, - "driverdisk": driverdisk.FC4_DriverDisk, - "firewall": firewall.FC3_Firewall, - "firstboot": firstboot.FC3_Firstboot, - "graphical": displaymode.FC3_DisplayMode, - "halt": reboot.FC6_Reboot, - "harddrive": method.FC6_Method, - "ignoredisk": ignoredisk.F8_IgnoreDisk, - "install": upgrade.FC3_Upgrade, - "interactive": interactive.FC3_Interactive, - "iscsi": iscsi.FC6_Iscsi, - "iscsiname": iscsiname.FC6_IscsiName, - "keyboard": keyboard.FC3_Keyboard, - "lang": lang.FC3_Lang, - "logging": logging.FC6_Logging, - "logvol": logvol.FC4_LogVol, - "mediacheck": mediacheck.FC4_MediaCheck, - "monitor": monitor.FC6_Monitor, - "multipath": multipath.FC6_MultiPath, - "network": network.F8_Network, - "nfs": method.FC6_Method, - "part": partition.FC4_Partition, - "partition": partition.FC4_Partition, - "poweroff": reboot.FC6_Reboot, - "raid": raid.F7_Raid, - "reboot": reboot.FC6_Reboot, - "repo": repo.F8_Repo, - "rootpw": rootpw.F8_RootPw, - "selinux": selinux.FC3_SELinux, - "services": services.FC6_Services, - "shutdown": reboot.FC6_Reboot, - "skipx": skipx.FC3_SkipX, - "text": displaymode.FC3_DisplayMode, - "timezone": timezone.FC6_Timezone, - "updates": updates.F7_Updates, - "upgrade": upgrade.FC3_Upgrade, - "url": method.FC6_Method, - "user": user.F8_User, - "vnc": vnc.FC6_Vnc, - "volgroup": volgroup.FC3_VolGroup, - "xconfig": xconfig.FC6_XConfig, - "zerombr": zerombr.FC3_ZeroMbr, - "zfcp": zfcp.FC3_ZFCP, - }, - - # based on f8 - F9: { - "auth": authconfig.FC3_Authconfig, - "authconfig": authconfig.FC3_Authconfig, - "autopart": autopart.F9_AutoPart, - "autostep": autostep.FC3_AutoStep, - "bootloader": bootloader.F8_Bootloader, - "cdrom": method.FC6_Method, - "clearpart": clearpart.FC3_ClearPart, - "cmdline": displaymode.FC3_DisplayMode, - "device": device.F8_Device, - "deviceprobe": deviceprobe.FC3_DeviceProbe, - "dmraid": dmraid.FC6_DmRaid, - "driverdisk": driverdisk.FC4_DriverDisk, - "firewall": firewall.F9_Firewall, - "firstboot": firstboot.FC3_Firstboot, - "graphical": displaymode.FC3_DisplayMode, - "halt": reboot.FC6_Reboot, - "harddrive": method.FC6_Method, - "ignoredisk": ignoredisk.F8_IgnoreDisk, - "install": upgrade.FC3_Upgrade, - "interactive": interactive.FC3_Interactive, - "iscsi": iscsi.FC6_Iscsi, - "iscsiname": iscsiname.FC6_IscsiName, - "keyboard": keyboard.FC3_Keyboard, - "lang": lang.FC3_Lang, - "logging": logging.FC6_Logging, - "logvol": logvol.F9_LogVol, - "mediacheck": mediacheck.FC4_MediaCheck, - "monitor": monitor.FC6_Monitor, - "multipath": multipath.FC6_MultiPath, - "network": network.F9_Network, - "nfs": method.FC6_Method, - "part": partition.F9_Partition, - "partition": partition.F9_Partition, - "poweroff": reboot.FC6_Reboot, - "raid": raid.F9_Raid, - "reboot": reboot.FC6_Reboot, - "repo": repo.F8_Repo, - "rootpw": rootpw.F8_RootPw, - "selinux": selinux.FC3_SELinux, - "services": services.FC6_Services, - "shutdown": reboot.FC6_Reboot, - "skipx": skipx.FC3_SkipX, - "text": displaymode.FC3_DisplayMode, - "timezone": timezone.FC6_Timezone, - "updates": updates.F7_Updates, - "upgrade": upgrade.FC3_Upgrade, - "url": method.FC6_Method, - "user": user.F8_User, - "vnc": vnc.F9_Vnc, - "volgroup": volgroup.FC3_VolGroup, - "xconfig": xconfig.F9_XConfig, - "zerombr": zerombr.F9_ZeroMbr, - "zfcp": zfcp.FC3_ZFCP, - }, - - # based on f9 - F10: { - "auth": authconfig.FC3_Authconfig, - "authconfig": authconfig.FC3_Authconfig, - "autopart": autopart.F9_AutoPart, - "autostep": autostep.FC3_AutoStep, - "bootloader": bootloader.F8_Bootloader, - "cdrom": method.FC6_Method, - "clearpart": clearpart.FC3_ClearPart, - "cmdline": displaymode.FC3_DisplayMode, - "device": device.F8_Device, - "deviceprobe": deviceprobe.FC3_DeviceProbe, - "dmraid": dmraid.FC6_DmRaid, - "driverdisk": driverdisk.FC4_DriverDisk, - "firewall": firewall.F10_Firewall, - "firstboot": firstboot.FC3_Firstboot, - "graphical": displaymode.FC3_DisplayMode, - "halt": reboot.FC6_Reboot, - "harddrive": method.FC6_Method, - "ignoredisk": ignoredisk.F8_IgnoreDisk, - "install": upgrade.FC3_Upgrade, - "interactive": interactive.FC3_Interactive, - "iscsi": iscsi.F10_Iscsi, - "iscsiname": iscsiname.FC6_IscsiName, - "keyboard": keyboard.FC3_Keyboard, - "lang": lang.FC3_Lang, - "logging": logging.FC6_Logging, - "logvol": logvol.F9_LogVol, - "mediacheck": mediacheck.FC4_MediaCheck, - "monitor": monitor.F10_Monitor, - "multipath": multipath.FC6_MultiPath, - "network": network.F9_Network, - "nfs": method.FC6_Method, - "part": partition.F9_Partition, - "partition": partition.F9_Partition, - "poweroff": reboot.FC6_Reboot, - "raid": raid.F9_Raid, - "reboot": reboot.FC6_Reboot, - "repo": repo.F8_Repo, - "rescue": rescue.F10_Rescue, - "rootpw": rootpw.F8_RootPw, - "selinux": selinux.FC3_SELinux, - "services": services.FC6_Services, - "shutdown": reboot.FC6_Reboot, - "skipx": skipx.FC3_SkipX, - "text": displaymode.FC3_DisplayMode, - "timezone": timezone.FC6_Timezone, - "updates": updates.F7_Updates, - "upgrade": upgrade.FC3_Upgrade, - "url": method.FC6_Method, - "user": user.F8_User, - "vnc": vnc.F9_Vnc, - "volgroup": volgroup.FC3_VolGroup, - "xconfig": xconfig.F10_XConfig, - "zerombr": zerombr.F9_ZeroMbr, - "zfcp": zfcp.FC3_ZFCP, - }, - - # based on f10 - F11: { - "auth": authconfig.FC3_Authconfig, - "authconfig": authconfig.FC3_Authconfig, - "autopart": autopart.F9_AutoPart, - "autostep": autostep.FC3_AutoStep, - "bootloader": bootloader.F8_Bootloader, - "cdrom": method.FC6_Method, - "clearpart": clearpart.FC3_ClearPart, - "cmdline": displaymode.FC3_DisplayMode, - "device": device.F8_Device, - "deviceprobe": deviceprobe.FC3_DeviceProbe, - "dmraid": dmraid.FC6_DmRaid, - "driverdisk": driverdisk.FC4_DriverDisk, - "firewall": firewall.F10_Firewall, - "firstboot": firstboot.FC3_Firstboot, - "graphical": displaymode.FC3_DisplayMode, - "halt": reboot.FC6_Reboot, - "harddrive": method.FC6_Method, - "ignoredisk": ignoredisk.F8_IgnoreDisk, - "install": upgrade.F11_Upgrade, - "interactive": interactive.FC3_Interactive, - "iscsi": iscsi.F10_Iscsi, - "iscsiname": iscsiname.FC6_IscsiName, - "keyboard": keyboard.FC3_Keyboard, - "lang": lang.FC3_Lang, - "logging": logging.FC6_Logging, - "logvol": logvol.F9_LogVol, - "mediacheck": mediacheck.FC4_MediaCheck, - "monitor": monitor.F10_Monitor, - "multipath": multipath.FC6_MultiPath, - "network": network.F9_Network, - "nfs": method.FC6_Method, - "part": partition.F11_Partition, - "partition": partition.F11_Partition, - "poweroff": reboot.FC6_Reboot, - "raid": raid.F9_Raid, - "reboot": reboot.FC6_Reboot, - "repo": repo.F11_Repo, - "rescue": rescue.F10_Rescue, - "rootpw": rootpw.F8_RootPw, - "selinux": selinux.FC3_SELinux, - "services": services.FC6_Services, - "shutdown": reboot.FC6_Reboot, - "skipx": skipx.FC3_SkipX, - "text": displaymode.FC3_DisplayMode, - "timezone": timezone.FC6_Timezone, - "updates": updates.F7_Updates, - "upgrade": upgrade.F11_Upgrade, - "url": method.FC6_Method, - "user": user.F8_User, - "vnc": vnc.F9_Vnc, - "volgroup": volgroup.FC3_VolGroup, - "xconfig": xconfig.F10_XConfig, - "zerombr": zerombr.F9_ZeroMbr, - "zfcp": zfcp.FC3_ZFCP, - }, - - # based on f11 - F12: { - "auth": authconfig.FC3_Authconfig, - "authconfig": authconfig.FC3_Authconfig, - "autopart": autopart.F12_AutoPart, - "autostep": autostep.FC3_AutoStep, - "bootloader": bootloader.F12_Bootloader, - "cdrom": method.FC6_Method, - "clearpart": clearpart.FC3_ClearPart, - "cmdline": displaymode.FC3_DisplayMode, - "device": device.F8_Device, - "deviceprobe": deviceprobe.FC3_DeviceProbe, - "dmraid": dmraid.FC6_DmRaid, - "driverdisk": driverdisk.F12_DriverDisk, - "fcoe": fcoe.F12_Fcoe, - "firewall": firewall.F10_Firewall, - "firstboot": firstboot.FC3_Firstboot, - "graphical": displaymode.FC3_DisplayMode, - "group": group.F12_Group, - "halt": reboot.FC6_Reboot, - "harddrive": method.FC6_Method, - "ignoredisk": ignoredisk.F8_IgnoreDisk, - "install": upgrade.F11_Upgrade, - "interactive": interactive.FC3_Interactive, - "iscsi": iscsi.F10_Iscsi, - "iscsiname": iscsiname.FC6_IscsiName, - "keyboard": keyboard.FC3_Keyboard, - "lang": lang.FC3_Lang, - "logging": logging.FC6_Logging, - "logvol": logvol.F12_LogVol, - "mediacheck": mediacheck.FC4_MediaCheck, - "monitor": monitor.F10_Monitor, - "multipath": multipath.FC6_MultiPath, - "network": network.F9_Network, - "nfs": method.FC6_Method, - "part": partition.F12_Partition, - "partition": partition.F12_Partition, - "poweroff": reboot.FC6_Reboot, - "raid": raid.F12_Raid, - "reboot": reboot.FC6_Reboot, - "repo": repo.F11_Repo, - "rescue": rescue.F10_Rescue, - "rootpw": rootpw.F8_RootPw, - "selinux": selinux.FC3_SELinux, - "services": services.FC6_Services, - "shutdown": reboot.FC6_Reboot, - "skipx": skipx.FC3_SkipX, - "text": displaymode.FC3_DisplayMode, - "timezone": timezone.FC6_Timezone, - "updates": updates.F7_Updates, - "upgrade": upgrade.F11_Upgrade, - "url": method.FC6_Method, - "user": user.F12_User, - "vnc": vnc.F9_Vnc, - "volgroup": volgroup.FC3_VolGroup, - "xconfig": xconfig.F10_XConfig, - "zerombr": zerombr.F9_ZeroMbr, - "zfcp": zfcp.F12_ZFCP, - }, - - # based on f12 - F13: { - "auth": authconfig.FC3_Authconfig, - "authconfig": authconfig.FC3_Authconfig, - "autopart": autopart.F12_AutoPart, - "autostep": autostep.FC3_AutoStep, - "bootloader": bootloader.F12_Bootloader, - "cdrom": method.F13_Method, - "clearpart": clearpart.FC3_ClearPart, - "cmdline": displaymode.FC3_DisplayMode, - "device": device.F8_Device, - "deviceprobe": deviceprobe.FC3_DeviceProbe, - "dmraid": dmraid.FC6_DmRaid, - "driverdisk": driverdisk.F12_DriverDisk, - "fcoe": fcoe.F13_Fcoe, - "firewall": firewall.F10_Firewall, - "firstboot": firstboot.FC3_Firstboot, - "graphical": displaymode.FC3_DisplayMode, - "group": group.F12_Group, - "halt": reboot.FC6_Reboot, - "harddrive": method.F13_Method, - "ignoredisk": ignoredisk.F8_IgnoreDisk, - "install": upgrade.F11_Upgrade, - "interactive": interactive.FC3_Interactive, - "iscsi": iscsi.F10_Iscsi, - "iscsiname": iscsiname.FC6_IscsiName, - "keyboard": keyboard.FC3_Keyboard, - "lang": lang.FC3_Lang, - "logging": logging.FC6_Logging, - "logvol": logvol.F12_LogVol, - "mediacheck": mediacheck.FC4_MediaCheck, - "monitor": monitor.F10_Monitor, - "multipath": multipath.FC6_MultiPath, - "network": network.F9_Network, - "nfs": method.F13_Method, - "part": partition.F12_Partition, - "partition": partition.F12_Partition, - "poweroff": reboot.FC6_Reboot, - "raid": raid.F13_Raid, - "reboot": reboot.FC6_Reboot, - "repo": repo.F13_Repo, - "rescue": rescue.F10_Rescue, - "rootpw": rootpw.F8_RootPw, - "selinux": selinux.FC3_SELinux, - "services": services.FC6_Services, - "shutdown": reboot.FC6_Reboot, - "skipx": skipx.FC3_SkipX, - "sshpw": sshpw.F13_SshPw, - "text": displaymode.FC3_DisplayMode, - "timezone": timezone.FC6_Timezone, - "updates": updates.F7_Updates, - "upgrade": upgrade.F11_Upgrade, - "url": method.F13_Method, - "user": user.F12_User, - "vnc": vnc.F9_Vnc, - "volgroup": volgroup.FC3_VolGroup, - "xconfig": xconfig.F10_XConfig, - "zerombr": zerombr.F9_ZeroMbr, - "zfcp": zfcp.F12_ZFCP, - }, - - # based on f13 - F14: { - "auth": authconfig.FC3_Authconfig, - "authconfig": authconfig.FC3_Authconfig, - "autopart": autopart.F12_AutoPart, - "autostep": autostep.FC3_AutoStep, - "bootloader": bootloader.F14_Bootloader, - "cdrom": method.F14_Method, - "clearpart": clearpart.FC3_ClearPart, - "cmdline": displaymode.FC3_DisplayMode, - "device": device.F8_Device, - "deviceprobe": deviceprobe.FC3_DeviceProbe, - "dmraid": dmraid.FC6_DmRaid, - "driverdisk": driverdisk.F14_DriverDisk, - "fcoe": fcoe.F13_Fcoe, - "firewall": firewall.F14_Firewall, - "firstboot": firstboot.FC3_Firstboot, - "graphical": displaymode.FC3_DisplayMode, - "group": group.F12_Group, - "halt": reboot.FC6_Reboot, - "harddrive": method.F14_Method, - "ignoredisk": ignoredisk.F14_IgnoreDisk, - "install": upgrade.F11_Upgrade, - "interactive": interactive.F14_Interactive, - "iscsi": iscsi.F10_Iscsi, - "iscsiname": iscsiname.FC6_IscsiName, - "keyboard": keyboard.FC3_Keyboard, - "lang": lang.FC3_Lang, - "logging": logging.FC6_Logging, - "logvol": logvol.F14_LogVol, - "mediacheck": mediacheck.FC4_MediaCheck, - "monitor": monitor.F10_Monitor, - "multipath": multipath.FC6_MultiPath, - "network": network.F9_Network, - "nfs": method.F14_Method, - "part": partition.F14_Partition, - "partition": partition.F14_Partition, - "poweroff": reboot.FC6_Reboot, - "raid": raid.F14_Raid, - "reboot": reboot.FC6_Reboot, - "repo": repo.F14_Repo, - "rescue": rescue.F10_Rescue, - "rootpw": rootpw.F8_RootPw, - "selinux": selinux.FC3_SELinux, - "services": services.FC6_Services, - "shutdown": reboot.FC6_Reboot, - "skipx": skipx.FC3_SkipX, - "sshpw": sshpw.F13_SshPw, - "text": displaymode.FC3_DisplayMode, - "timezone": timezone.FC6_Timezone, - "updates": updates.F7_Updates, - "upgrade": upgrade.F11_Upgrade, - "url": method.F14_Method, - "user": user.F12_User, - "vnc": vnc.F9_Vnc, - "volgroup": volgroup.FC3_VolGroup, - "xconfig": xconfig.F14_XConfig, - "zerombr": zerombr.F9_ZeroMbr, - "zfcp": zfcp.F14_ZFCP, - }, - - # based on f14 - F15: { - "auth": authconfig.FC3_Authconfig, - "authconfig": authconfig.FC3_Authconfig, - "autopart": autopart.F12_AutoPart, - "autostep": autostep.FC3_AutoStep, - "bootloader": bootloader.F15_Bootloader, - "cdrom": method.F14_Method, - "clearpart": clearpart.FC3_ClearPart, - "cmdline": displaymode.FC3_DisplayMode, - "device": device.F8_Device, - "deviceprobe": deviceprobe.FC3_DeviceProbe, - "dmraid": dmraid.FC6_DmRaid, - "driverdisk": driverdisk.F14_DriverDisk, - "fcoe": fcoe.F13_Fcoe, - "firewall": firewall.F14_Firewall, - "firstboot": firstboot.FC3_Firstboot, - "graphical": displaymode.FC3_DisplayMode, - "group": group.F12_Group, - "halt": reboot.FC6_Reboot, - "harddrive": method.F14_Method, - "ignoredisk": ignoredisk.F14_IgnoreDisk, - "install": upgrade.F11_Upgrade, - "iscsi": iscsi.F10_Iscsi, - "iscsiname": iscsiname.FC6_IscsiName, - "keyboard": keyboard.FC3_Keyboard, - "lang": lang.FC3_Lang, - "logging": logging.FC6_Logging, - "logvol": logvol.F15_LogVol, - "mediacheck": mediacheck.FC4_MediaCheck, - "monitor": monitor.F10_Monitor, - "multipath": multipath.FC6_MultiPath, - "network": network.F9_Network, - "nfs": method.F14_Method, - "part": partition.F14_Partition, - "partition": partition.F14_Partition, - "poweroff": reboot.FC6_Reboot, - "raid": raid.F15_Raid, - "reboot": reboot.FC6_Reboot, - "repo": repo.F15_Repo, - "rescue": rescue.F10_Rescue, - "rootpw": rootpw.F8_RootPw, - "selinux": selinux.FC3_SELinux, - "services": services.FC6_Services, - "shutdown": reboot.FC6_Reboot, - "skipx": skipx.FC3_SkipX, - "sshpw": sshpw.F13_SshPw, - "text": displaymode.FC3_DisplayMode, - "timezone": timezone.FC6_Timezone, - "updates": updates.F7_Updates, - "upgrade": upgrade.F11_Upgrade, - "url": method.F14_Method, - "user": user.F12_User, - "vnc": vnc.F9_Vnc, - "volgroup": volgroup.FC3_VolGroup, - "xconfig": xconfig.F14_XConfig, - "zerombr": zerombr.F9_ZeroMbr, - "zfcp": zfcp.F14_ZFCP, - }, - - # based on f15 - F16: { - "auth": authconfig.FC3_Authconfig, - "authconfig": authconfig.FC3_Authconfig, - "autopart": autopart.F12_AutoPart, - "autostep": autostep.FC3_AutoStep, - "bootloader": bootloader.F15_Bootloader, - "cdrom": method.F14_Method, - "clearpart": clearpart.FC3_ClearPart, - "cmdline": displaymode.FC3_DisplayMode, - "device": device.F8_Device, - "deviceprobe": deviceprobe.FC3_DeviceProbe, - "dmraid": dmraid.FC6_DmRaid, - "driverdisk": driverdisk.F14_DriverDisk, - "fcoe": fcoe.F13_Fcoe, - "firewall": firewall.F14_Firewall, - "firstboot": firstboot.FC3_Firstboot, - "graphical": displaymode.FC3_DisplayMode, - "group": group.F12_Group, - "halt": reboot.FC6_Reboot, - "harddrive": method.F14_Method, - "ignoredisk": ignoredisk.F14_IgnoreDisk, - "install": upgrade.F11_Upgrade, - "iscsi": iscsi.F10_Iscsi, - "iscsiname": iscsiname.FC6_IscsiName, - "keyboard": keyboard.FC3_Keyboard, - "lang": lang.FC3_Lang, - "logging": logging.FC6_Logging, - "logvol": logvol.F15_LogVol, - "mediacheck": mediacheck.FC4_MediaCheck, - "monitor": monitor.F10_Monitor, - "multipath": multipath.FC6_MultiPath, - "network": network.F16_Network, - "nfs": method.F14_Method, - "part": partition.F14_Partition, - "partition": partition.F14_Partition, - "poweroff": reboot.FC6_Reboot, - "raid": raid.F15_Raid, - "reboot": reboot.FC6_Reboot, - "repo": repo.F15_Repo, - "rescue": rescue.F10_Rescue, - "rootpw": rootpw.F8_RootPw, - "selinux": selinux.FC3_SELinux, - "services": services.FC6_Services, - "shutdown": reboot.FC6_Reboot, - "skipx": skipx.FC3_SkipX, - "sshpw": sshpw.F13_SshPw, - "text": displaymode.FC3_DisplayMode, - "timezone": timezone.FC6_Timezone, - "updates": updates.F7_Updates, - "upgrade": upgrade.F11_Upgrade, - "url": method.F14_Method, - "user": user.F12_User, - "vnc": vnc.F9_Vnc, - "volgroup": volgroup.FC3_VolGroup, - "xconfig": xconfig.F14_XConfig, - "zerombr": zerombr.F9_ZeroMbr, - "zfcp": zfcp.F14_ZFCP, - }, - - # based on fc1 - RHEL3: { - "auth": authconfig.FC3_Authconfig, - "authconfig": authconfig.FC3_Authconfig, - "autopart": autopart.FC3_AutoPart, - "autostep": autostep.FC3_AutoStep, - "bootloader": bootloader.FC3_Bootloader, - "cdrom": method.FC3_Method, - "clearpart": clearpart.FC3_ClearPart, - "cmdline": displaymode.FC3_DisplayMode, - "device": device.FC3_Device, - "deviceprobe": deviceprobe.FC3_DeviceProbe, - "driverdisk": driverdisk.FC3_DriverDisk, - "firewall": firewall.FC3_Firewall, - "firstboot": firstboot.FC3_Firstboot, - "graphical": displaymode.FC3_DisplayMode, - "halt": reboot.FC3_Reboot, - "harddrive": method.FC3_Method, - "ignoredisk": ignoredisk.FC3_IgnoreDisk, - "install": upgrade.FC3_Upgrade, - "interactive": interactive.FC3_Interactive, - "keyboard": keyboard.FC3_Keyboard, - "lang": lang.FC3_Lang, - "langsupport": langsupport.FC3_LangSupport, - "lilo": bootloader.FC3_Bootloader, - "lilocheck": lilocheck.FC3_LiloCheck, - "logvol": logvol.FC3_LogVol, - "monitor": monitor.FC3_Monitor, - "mouse": mouse.RHEL3_Mouse, - "network": network.FC3_Network, - "nfs": method.FC3_Method, - "part": partition.FC3_Partition, - "partition": partition.FC3_Partition, - "poweroff": reboot.FC3_Reboot, - "raid": raid.FC3_Raid, - "reboot": reboot.FC3_Reboot, - "rootpw": rootpw.FC3_RootPw, - "shutdown": reboot.FC3_Reboot, - "skipx": skipx.FC3_SkipX, - "text": displaymode.FC3_DisplayMode, - "timezone": timezone.FC3_Timezone, - "upgrade": upgrade.FC3_Upgrade, - "url": method.FC3_Method, - "vnc": vnc.FC3_Vnc, - "volgroup": volgroup.FC3_VolGroup, - "xconfig": xconfig.FC3_XConfig, - "zerombr": zerombr.FC3_ZeroMbr, - }, - - # based on fc3 - RHEL4: { - "auth": authconfig.FC3_Authconfig, - "authconfig": authconfig.FC3_Authconfig, - "autopart": autopart.FC3_AutoPart, - "autostep": autostep.FC3_AutoStep, - "bootloader": bootloader.FC3_Bootloader, - "cdrom": method.FC3_Method, - "clearpart": clearpart.FC3_ClearPart, - "cmdline": displaymode.FC3_DisplayMode, - "device": device.FC3_Device, - "deviceprobe": deviceprobe.FC3_DeviceProbe, - "driverdisk": driverdisk.FC4_DriverDisk, - "firewall": firewall.FC3_Firewall, - "firstboot": firstboot.FC3_Firstboot, - "graphical": displaymode.FC3_DisplayMode, - "halt": reboot.FC3_Reboot, - "harddrive": method.FC3_Method, - "ignoredisk": ignoredisk.F8_IgnoreDisk, - "install": upgrade.FC3_Upgrade, - "interactive": interactive.FC3_Interactive, - "keyboard": keyboard.FC3_Keyboard, - "lang": lang.FC3_Lang, - "langsupport": langsupport.FC3_LangSupport, - "lilo": bootloader.FC3_Bootloader, - "lilocheck": lilocheck.FC3_LiloCheck, - "logvol": logvol.FC3_LogVol, - "monitor": monitor.FC3_Monitor, - "mouse": mouse.FC3_Mouse, - "network": network.RHEL4_Network, - "nfs": method.FC3_Method, - "part": partition.FC3_Partition, - "partition": partition.FC3_Partition, - "poweroff": reboot.FC3_Reboot, - "raid": raid.FC3_Raid, - "reboot": reboot.FC3_Reboot, - "rootpw": rootpw.FC3_RootPw, - "selinux": selinux.FC3_SELinux, - "shutdown": reboot.FC3_Reboot, - "skipx": skipx.FC3_SkipX, - "text": displaymode.FC3_DisplayMode, - "timezone": timezone.FC3_Timezone, - "upgrade": upgrade.FC3_Upgrade, - "url": method.FC3_Method, - "vnc": vnc.FC3_Vnc, - "volgroup": volgroup.FC3_VolGroup, - "xconfig": xconfig.FC3_XConfig, - "zerombr": zerombr.FC3_ZeroMbr, - "zfcp": zfcp.FC3_ZFCP, - }, - - # based on fc6 - RHEL5: { - "auth": authconfig.FC3_Authconfig, - "authconfig": authconfig.FC3_Authconfig, - "autopart": autopart.F9_AutoPart, - "autostep": autostep.FC3_AutoStep, - "bootloader": bootloader.RHEL5_Bootloader, - "cdrom": method.FC6_Method, - "clearpart": clearpart.FC3_ClearPart, - "cmdline": displaymode.FC3_DisplayMode, - "device": device.FC3_Device, - "deviceprobe": deviceprobe.FC3_DeviceProbe, - "dmraid": dmraid.FC6_DmRaid, - "driverdisk": driverdisk.F12_DriverDisk, - "firewall": firewall.FC3_Firewall, - "firstboot": firstboot.FC3_Firstboot, - "graphical": displaymode.FC3_DisplayMode, - "halt": reboot.FC6_Reboot, - "harddrive": method.FC6_Method, - "ignoredisk": ignoredisk.F8_IgnoreDisk, - "install": upgrade.FC3_Upgrade, - "interactive": interactive.FC3_Interactive, - "iscsi": iscsi.FC6_Iscsi, - "iscsiname": iscsiname.FC6_IscsiName, - "key": key.RHEL5_Key, - "keyboard": keyboard.FC3_Keyboard, - "lang": lang.FC3_Lang, - "langsupport": langsupport.FC5_LangSupport, - "logging": logging.FC6_Logging, - "logvol": logvol.RHEL5_LogVol, - "mediacheck": mediacheck.FC4_MediaCheck, - "monitor": monitor.FC6_Monitor, - "mouse": mouse.FC3_Mouse, - "multipath": multipath.FC6_MultiPath, - "network": network.RHEL5_Network, - "nfs": method.FC6_Method, - "part": partition.RHEL5_Partition, - "partition": partition.RHEL5_Partition, - "poweroff": reboot.FC6_Reboot, - "raid": raid.RHEL5_Raid, - "reboot": reboot.FC6_Reboot, - "repo": repo.FC6_Repo, - "rootpw": rootpw.FC3_RootPw, - "services": services.FC6_Services, - "selinux": selinux.FC3_SELinux, - "shutdown": reboot.FC6_Reboot, - "skipx": skipx.FC3_SkipX, - "text": displaymode.FC3_DisplayMode, - "timezone": timezone.FC6_Timezone, - "upgrade": upgrade.FC3_Upgrade, - "user": user.FC6_User, - "url": method.FC6_Method, - "vnc": vnc.FC6_Vnc, - "volgroup": volgroup.FC3_VolGroup, - "xconfig": xconfig.FC6_XConfig, - "zerombr": zerombr.FC3_ZeroMbr, - "zfcp": zfcp.FC3_ZFCP, - }, - - # based on f13ish - RHEL6: { - "auth": authconfig.FC3_Authconfig, - "authconfig": authconfig.FC3_Authconfig, - "autopart": autopart.F12_AutoPart, - "autostep": autostep.FC3_AutoStep, - "bootloader": bootloader.RHEL6_Bootloader, - "cdrom": method.RHEL6_Method, - "clearpart": clearpart.FC3_ClearPart, - "cmdline": displaymode.FC3_DisplayMode, - "device": device.F8_Device, - "deviceprobe": deviceprobe.FC3_DeviceProbe, - "dmraid": dmraid.FC6_DmRaid, - "driverdisk": driverdisk.F12_DriverDisk, - "fcoe": fcoe.F13_Fcoe, - "firewall": firewall.F10_Firewall, - "firstboot": firstboot.FC3_Firstboot, - "graphical": displaymode.FC3_DisplayMode, - "group": group.F12_Group, - "halt": reboot.FC6_Reboot, - "harddrive": method.RHEL6_Method, - "ignoredisk": ignoredisk.RHEL6_IgnoreDisk, - "install": upgrade.F11_Upgrade, - "interactive": interactive.FC3_Interactive, - "iscsi": iscsi.F10_Iscsi, - "iscsiname": iscsiname.FC6_IscsiName, - "keyboard": keyboard.FC3_Keyboard, - "lang": lang.FC3_Lang, - "logging": logging.FC6_Logging, - "logvol": logvol.F12_LogVol, - "mediacheck": mediacheck.FC4_MediaCheck, - "monitor": monitor.F10_Monitor, - "multipath": multipath.FC6_MultiPath, - "network": network.RHEL6_Network, - "nfs": method.RHEL6_Method, - "part": partition.F12_Partition, - "partition": partition.F12_Partition, - "poweroff": reboot.FC6_Reboot, - "raid": raid.F13_Raid, - "reboot": reboot.FC6_Reboot, - "repo": repo.RHEL6_Repo, - "rescue": rescue.F10_Rescue, - "rootpw": rootpw.F8_RootPw, - "selinux": selinux.FC3_SELinux, - "services": services.FC6_Services, - "shutdown": reboot.FC6_Reboot, - "skipx": skipx.FC3_SkipX, - "sshpw": sshpw.F13_SshPw, - "text": displaymode.FC3_DisplayMode, - "timezone": timezone.FC6_Timezone, - "updates": updates.F7_Updates, - "upgrade": upgrade.F11_Upgrade, - "url": method.RHEL6_Method, - "user": user.F12_User, - "vnc": vnc.F9_Vnc, - "volgroup": volgroup.FC3_VolGroup, - "xconfig": xconfig.F10_XConfig, - "zerombr": zerombr.F9_ZeroMbr, - "zfcp": zfcp.F12_ZFCP, - } -} - -# This map is keyed on kickstart syntax version as provided by -# pykickstart.version. Within each sub-dict is a mapping from a data object -# name to the class that provides it. This is a bijective mapping - that is, -# each name maps to exactly one data class and all data classes have a name. -# More than one instance of each class is allowed to exist, however. -dataMap = { - FC3: { - "DriverDiskData": driverdisk.FC3_DriverDiskData, - "LogVolData": logvol.FC3_LogVolData, - "NetworkData": network.FC3_NetworkData, - "PartData": partition.FC3_PartData, - "RaidData": raid.FC3_RaidData, - "VolGroupData": volgroup.FC3_VolGroupData, - "ZFCPData": zfcp.FC3_ZFCPData, - }, - FC4: { - "DriverDiskData": driverdisk.FC4_DriverDiskData, - "LogVolData": logvol.FC4_LogVolData, - "NetworkData": network.FC4_NetworkData, - "PartData": partition.FC4_PartData, - "RaidData": raid.FC4_RaidData, - "VolGroupData": volgroup.FC3_VolGroupData, - "ZFCPData": zfcp.FC3_ZFCPData, - }, - FC5: { - "DriverDiskData": driverdisk.FC4_DriverDiskData, - "LogVolData": logvol.FC4_LogVolData, - "NetworkData": network.FC4_NetworkData, - "PartData": partition.FC4_PartData, - "RaidData": raid.FC5_RaidData, - "VolGroupData": volgroup.FC3_VolGroupData, - "ZFCPData": zfcp.FC3_ZFCPData, - }, - FC6: { - "DriverDiskData": driverdisk.FC4_DriverDiskData, - "DmRaidData": dmraid.FC6_DmRaidData, - "IscsiData": iscsi.FC6_IscsiData, - "LogVolData": logvol.FC4_LogVolData, - "MultiPathData": multipath.FC6_MultiPathData, - "NetworkData": network.FC6_NetworkData, - "PartData": partition.FC4_PartData, - "RaidData": raid.FC5_RaidData, - "RepoData": repo.FC6_RepoData, - "UserData": user.FC6_UserData, - "VolGroupData": volgroup.FC3_VolGroupData, - "ZFCPData": zfcp.FC3_ZFCPData, - }, - F7: { - "DriverDiskData": driverdisk.FC4_DriverDiskData, - "DmRaidData": dmraid.FC6_DmRaidData, - "IscsiData": iscsi.FC6_IscsiData, - "LogVolData": logvol.FC4_LogVolData, - "MultiPathData": multipath.FC6_MultiPathData, - "NetworkData": network.FC6_NetworkData, - "PartData": partition.FC4_PartData, - "RaidData": raid.F7_RaidData, - "RepoData": repo.FC6_RepoData, - "UserData": user.FC6_UserData, - "VolGroupData": volgroup.FC3_VolGroupData, - "ZFCPData": zfcp.FC3_ZFCPData, - }, - F8: { - "DriverDiskData": driverdisk.FC4_DriverDiskData, - "DeviceData": device.F8_DeviceData, - "DmRaidData": dmraid.FC6_DmRaidData, - "IscsiData": iscsi.FC6_IscsiData, - "LogVolData": logvol.FC4_LogVolData, - "MultiPathData": multipath.FC6_MultiPathData, - "NetworkData": network.F8_NetworkData, - "PartData": partition.FC4_PartData, - "RaidData": raid.F7_RaidData, - "RepoData": repo.F8_RepoData, - "UserData": user.F8_UserData, - "VolGroupData": volgroup.FC3_VolGroupData, - "ZFCPData": zfcp.FC3_ZFCPData, - }, - F9: { - "DriverDiskData": driverdisk.FC4_DriverDiskData, - "DeviceData": device.F8_DeviceData, - "DmRaidData": dmraid.FC6_DmRaidData, - "IscsiData": iscsi.FC6_IscsiData, - "LogVolData": logvol.F9_LogVolData, - "MultiPathData": multipath.FC6_MultiPathData, - "NetworkData": network.F8_NetworkData, - "PartData": partition.F9_PartData, - "RaidData": raid.F9_RaidData, - "RepoData": repo.F8_RepoData, - "UserData": user.F8_UserData, - "VolGroupData": volgroup.FC3_VolGroupData, - "ZFCPData": zfcp.FC3_ZFCPData, - }, - F10: { - "DriverDiskData": driverdisk.FC4_DriverDiskData, - "DeviceData": device.F8_DeviceData, - "DmRaidData": dmraid.FC6_DmRaidData, - "IscsiData": iscsi.F10_IscsiData, - "LogVolData": logvol.F9_LogVolData, - "MultiPathData": multipath.FC6_MultiPathData, - "NetworkData": network.F8_NetworkData, - "PartData": partition.F9_PartData, - "RaidData": raid.F9_RaidData, - "RepoData": repo.F8_RepoData, - "UserData": user.F8_UserData, - "VolGroupData": volgroup.FC3_VolGroupData, - "ZFCPData": zfcp.FC3_ZFCPData, - }, - F11: { - "DriverDiskData": driverdisk.FC4_DriverDiskData, - "DeviceData": device.F8_DeviceData, - "DmRaidData": dmraid.FC6_DmRaidData, - "IscsiData": iscsi.F10_IscsiData, - "LogVolData": logvol.F9_LogVolData, - "MultiPathData": multipath.FC6_MultiPathData, - "NetworkData": network.F8_NetworkData, - "PartData": partition.F11_PartData, - "RaidData": raid.F9_RaidData, - "RepoData": repo.F11_RepoData, - "UserData": user.F8_UserData, - "VolGroupData": volgroup.FC3_VolGroupData, - "ZFCPData": zfcp.FC3_ZFCPData, - }, - F12: { - "DriverDiskData": driverdisk.F12_DriverDiskData, - "DeviceData": device.F8_DeviceData, - "DmRaidData": dmraid.FC6_DmRaidData, - "FcoeData": fcoe.F12_FcoeData, - "GroupData": group.F12_GroupData, - "IscsiData": iscsi.F10_IscsiData, - "LogVolData": logvol.F12_LogVolData, - "MultiPathData": multipath.FC6_MultiPathData, - "NetworkData": network.F8_NetworkData, - "PartData": partition.F12_PartData, - "RaidData": raid.F12_RaidData, - "RepoData": repo.F11_RepoData, - "UserData": user.F12_UserData, - "VolGroupData": volgroup.FC3_VolGroupData, - "ZFCPData": zfcp.F12_ZFCPData, - }, - F13: { - "DriverDiskData": driverdisk.F12_DriverDiskData, - "DeviceData": device.F8_DeviceData, - "DmRaidData": dmraid.FC6_DmRaidData, - "FcoeData": fcoe.F13_FcoeData, - "GroupData": group.F12_GroupData, - "IscsiData": iscsi.F10_IscsiData, - "LogVolData": logvol.F12_LogVolData, - "MultiPathData": multipath.FC6_MultiPathData, - "NetworkData": network.F8_NetworkData, - "PartData": partition.F12_PartData, - "RaidData": raid.F13_RaidData, - "RepoData": repo.F13_RepoData, - "SshPwData": sshpw.F13_SshPwData, - "UserData": user.F12_UserData, - "VolGroupData": volgroup.FC3_VolGroupData, - "ZFCPData": zfcp.F12_ZFCPData, - }, - F14: { - "DriverDiskData": driverdisk.F14_DriverDiskData, - "DeviceData": device.F8_DeviceData, - "DmRaidData": dmraid.FC6_DmRaidData, - "FcoeData": fcoe.F13_FcoeData, - "GroupData": group.F12_GroupData, - "IscsiData": iscsi.F10_IscsiData, - "LogVolData": logvol.F14_LogVolData, - "MultiPathData": multipath.FC6_MultiPathData, - "NetworkData": network.F8_NetworkData, - "PartData": partition.F14_PartData, - "RaidData": raid.F14_RaidData, - "RepoData": repo.F14_RepoData, - "SshPwData": sshpw.F13_SshPwData, - "UserData": user.F12_UserData, - "VolGroupData": volgroup.FC3_VolGroupData, - "ZFCPData": zfcp.F14_ZFCPData, - }, - F15: { - "DriverDiskData": driverdisk.F14_DriverDiskData, - "DeviceData": device.F8_DeviceData, - "DmRaidData": dmraid.FC6_DmRaidData, - "FcoeData": fcoe.F13_FcoeData, - "GroupData": group.F12_GroupData, - "IscsiData": iscsi.F10_IscsiData, - "LogVolData": logvol.F15_LogVolData, - "MultiPathData": multipath.FC6_MultiPathData, - "NetworkData": network.F8_NetworkData, - "PartData": partition.F14_PartData, - "RaidData": raid.F15_RaidData, - "RepoData": repo.F15_RepoData, - "SshPwData": sshpw.F13_SshPwData, - "UserData": user.F12_UserData, - "VolGroupData": volgroup.FC3_VolGroupData, - "ZFCPData": zfcp.F14_ZFCPData, - }, - F16: { - "DriverDiskData": driverdisk.F14_DriverDiskData, - "DeviceData": device.F8_DeviceData, - "DmRaidData": dmraid.FC6_DmRaidData, - "FcoeData": fcoe.F13_FcoeData, - "GroupData": group.F12_GroupData, - "IscsiData": iscsi.F10_IscsiData, - "LogVolData": logvol.F15_LogVolData, - "MultiPathData": multipath.FC6_MultiPathData, - "NetworkData": network.F16_NetworkData, - "PartData": partition.F14_PartData, - "RaidData": raid.F15_RaidData, - "RepoData": repo.F15_RepoData, - "SshPwData": sshpw.F13_SshPwData, - "UserData": user.F12_UserData, - "VolGroupData": volgroup.FC3_VolGroupData, - "ZFCPData": zfcp.F14_ZFCPData, - }, - RHEL3: { - "DriverDiskData": driverdisk.FC3_DriverDiskData, - "LogVolData": logvol.FC3_LogVolData, - "NetworkData": network.RHEL4_NetworkData, - "PartData": partition.FC3_PartData, - "RaidData": raid.FC3_RaidData, - "VolGroupData": volgroup.FC3_VolGroupData, - "ZFCPData": zfcp.FC3_ZFCPData, - }, - RHEL4: { - "DriverDiskData": driverdisk.FC4_DriverDiskData, - "LogVolData": logvol.FC3_LogVolData, - "NetworkData": network.RHEL4_NetworkData, - "PartData": partition.FC3_PartData, - "RaidData": raid.FC3_RaidData, - "VolGroupData": volgroup.FC3_VolGroupData, - "ZFCPData": zfcp.FC3_ZFCPData, - }, - RHEL5: { - "DriverDiskData": driverdisk.F12_DriverDiskData, - "DmRaidData": dmraid.FC6_DmRaidData, - "IscsiData": iscsi.FC6_IscsiData, - "LogVolData": logvol.RHEL5_LogVolData, - "MultiPathData": multipath.FC6_MultiPathData, - "NetworkData": network.FC6_NetworkData, - "PartData": partition.RHEL5_PartData, - "RaidData": raid.RHEL5_RaidData, - "RepoData": repo.FC6_RepoData, - "UserData": user.FC6_UserData, - "VolGroupData": volgroup.FC3_VolGroupData, - "ZFCPData": zfcp.FC3_ZFCPData, - }, - RHEL6: { - "DriverDiskData": driverdisk.F12_DriverDiskData, - "DeviceData": device.F8_DeviceData, - "DmRaidData": dmraid.FC6_DmRaidData, - "FcoeData": fcoe.F13_FcoeData, - "GroupData": group.F12_GroupData, - "IscsiData": iscsi.F10_IscsiData, - "LogVolData": logvol.F12_LogVolData, - "MultiPathData": multipath.FC6_MultiPathData, - "NetworkData": network.RHEL6_NetworkData, - "PartData": partition.F12_PartData, - "RaidData": raid.F13_RaidData, - "RepoData": repo.RHEL6_RepoData, - "SshPwData": sshpw.F13_SshPwData, - "UserData": user.F12_UserData, - "VolGroupData": volgroup.FC3_VolGroupData, - "ZFCPData": zfcp.F12_ZFCPData, - } -} diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/f10.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/f10.py deleted file mode 100644 index 17c8211bbf..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/handlers/f10.py +++ /dev/null @@ -1,24 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2008 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.version import * - -class F10Handler(BaseHandler): - version = F10 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/f11.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/f11.py deleted file mode 100644 index d21aee3e8b..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/handlers/f11.py +++ /dev/null @@ -1,24 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2008 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.version import * - -class F11Handler(BaseHandler): - version = F11 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/f12.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/f12.py deleted file mode 100644 index cea3ecef6b..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/handlers/f12.py +++ /dev/null @@ -1,24 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2009 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.version import * - -class F12Handler(BaseHandler): - version = F12 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/f13.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/f13.py deleted file mode 100644 index b94c738f79..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/handlers/f13.py +++ /dev/null @@ -1,24 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2009 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.version import * - -class F13Handler(BaseHandler): - version = F13 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/f14.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/f14.py deleted file mode 100644 index 478f75d15e..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/handlers/f14.py +++ /dev/null @@ -1,24 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2010 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.version import * - -class F14Handler(BaseHandler): - version = F14 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/f15.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/f15.py deleted file mode 100644 index 12aecb4c1a..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/handlers/f15.py +++ /dev/null @@ -1,24 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2010 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.version import * - -class F15Handler(BaseHandler): - version = F15 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/f16.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/f16.py deleted file mode 100644 index 3c52f8d754..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/handlers/f16.py +++ /dev/null @@ -1,24 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2011 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.version import * - -class F16Handler(BaseHandler): - version = F16 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/f7.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/f7.py deleted file mode 100644 index 5e856ea983..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/handlers/f7.py +++ /dev/null @@ -1,24 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.version import * - -class F7Handler(BaseHandler): - version = F7 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/f8.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/f8.py deleted file mode 100644 index 1a978810f4..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/handlers/f8.py +++ /dev/null @@ -1,24 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.version import * - -class F8Handler(BaseHandler): - version = F8 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/f9.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/f9.py deleted file mode 100644 index 116f1b57c9..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/handlers/f9.py +++ /dev/null @@ -1,24 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.version import * - -class F9Handler(BaseHandler): - version = F9 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/fc3.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/fc3.py deleted file mode 100644 index a115dc2646..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/handlers/fc3.py +++ /dev/null @@ -1,24 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.version import * - -class FC3Handler(BaseHandler): - version = FC3 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/fc4.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/fc4.py deleted file mode 100644 index fd47b732ef..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/handlers/fc4.py +++ /dev/null @@ -1,24 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.version import * - -class FC4Handler(BaseHandler): - version = FC4 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/fc5.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/fc5.py deleted file mode 100644 index bcdc29d23a..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/handlers/fc5.py +++ /dev/null @@ -1,24 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.version import * - -class FC5Handler(BaseHandler): - version = FC5 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/fc6.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/fc6.py deleted file mode 100644 index c83a929f84..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/handlers/fc6.py +++ /dev/null @@ -1,24 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.version import * - -class FC6Handler(BaseHandler): - version = FC6 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/rhel3.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/rhel3.py deleted file mode 100644 index 131763c2a8..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/handlers/rhel3.py +++ /dev/null @@ -1,24 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.version import * - -class RHEL3Handler(BaseHandler): - version = RHEL3 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/rhel4.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/rhel4.py deleted file mode 100644 index 3496c43ea5..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/handlers/rhel4.py +++ /dev/null @@ -1,24 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.version import * - -class RHEL4Handler(BaseHandler): - version = RHEL4 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/rhel5.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/rhel5.py deleted file mode 100644 index abb7a8d36c..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/handlers/rhel5.py +++ /dev/null @@ -1,24 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.version import * - -class RHEL5Handler(BaseHandler): - version = RHEL5 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/rhel6.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/rhel6.py deleted file mode 100644 index 7202419780..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/handlers/rhel6.py +++ /dev/null @@ -1,24 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2010 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -from pykickstart.base import * -from pykickstart.version import * - -class RHEL6Handler(BaseHandler): - version = RHEL6 diff --git a/scripts/lib/mic/3rdparty/pykickstart/ko.py b/scripts/lib/mic/3rdparty/pykickstart/ko.py deleted file mode 100644 index 1350d19c70..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/ko.py +++ /dev/null @@ -1,37 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2009 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -""" -Base classes for internal pykickstart use. - -The module exports the following important classes: - - KickstartObject - The base class for all classes in pykickstart -""" - -class KickstartObject(object): - """The base class for all other classes in pykickstart.""" - def __init__(self, *args, **kwargs): - """Create a new KickstartObject instance. All other classes in - pykickstart should be derived from this one. Instance attributes: - """ - pass - - def __str__(self): - return "" diff --git a/scripts/lib/mic/3rdparty/pykickstart/options.py b/scripts/lib/mic/3rdparty/pykickstart/options.py deleted file mode 100644 index 341c5d7298..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/options.py +++ /dev/null @@ -1,204 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -""" -Specialized option handling. - -This module exports two classes: - - KSOptionParser - A specialized subclass of OptionParser to be used - in BaseHandler subclasses. - - KSOption - A specialized subclass of Option. -""" -import warnings -from copy import copy -from optparse import * - -from constants import * -from errors import * -from version import * - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -class KSOptionParser(OptionParser): - """A specialized subclass of optparse.OptionParser to handle extra option - attribute checking, work error reporting into the KickstartParseError - framework, and to turn off the default help. - """ - def exit(self, status=0, msg=None): - pass - - def error(self, msg): - if self.lineno != None: - raise KickstartParseError, formatErrorMsg(self.lineno, msg=msg) - else: - raise KickstartParseError, msg - - def keys(self): - retval = [] - - for opt in self.option_list: - if opt not in retval: - retval.append(opt.dest) - - return retval - - def _init_parsing_state (self): - OptionParser._init_parsing_state(self) - self.option_seen = {} - - def check_values (self, values, args): - def seen(self, option): - return self.option_seen.has_key(option) - - def usedTooNew(self, option): - return option.introduced and option.introduced > self.version - - def usedDeprecated(self, option): - return option.deprecated - - def usedRemoved(self, option): - return option.removed and option.removed <= self.version - - for option in filter(lambda o: isinstance(o, Option), self.option_list): - if option.required and not seen(self, option): - raise KickstartValueError, formatErrorMsg(self.lineno, _("Option %s is required") % option) - elif seen(self, option) and usedTooNew(self, option): - mapping = {"option": option, "intro": versionToString(option.introduced), - "version": versionToString(self.version)} - self.error(_("The %(option)s option was introduced in version %(intro)s, but you are using kickstart syntax version %(version)s.") % mapping) - elif seen(self, option) and usedRemoved(self, option): - mapping = {"option": option, "removed": versionToString(option.removed), - "version": versionToString(self.version)} - - if option.removed == self.version: - self.error(_("The %(option)s option is no longer supported.") % mapping) - else: - self.error(_("The %(option)s option was removed in version %(removed)s, but you are using kickstart syntax version %(version)s.") % mapping) - elif seen(self, option) and usedDeprecated(self, option): - mapping = {"lineno": self.lineno, "option": option} - warnings.warn(_("Ignoring deprecated option on line %(lineno)s: The %(option)s option has been deprecated and no longer has any effect. It may be removed from future releases, which will result in a fatal error from kickstart. Please modify your kickstart file to remove this option.") % mapping, DeprecationWarning) - - return (values, args) - - def parse_args(self, *args, **kwargs): - if kwargs.has_key("lineno"): - self.lineno = kwargs.pop("lineno") - - return OptionParser.parse_args(self, **kwargs) - - def __init__(self, mapping=None, version=None): - """Create a new KSOptionParser instance. Each KickstartCommand - subclass should create one instance of KSOptionParser, providing - at least the lineno attribute. mapping and version are not required. - Instance attributes: - - mapping -- A mapping from option strings to different values. - version -- The version of the kickstart syntax we are checking - against. - """ - OptionParser.__init__(self, option_class=KSOption, - add_help_option=False, - conflict_handler="resolve") - if mapping is None: - self.map = {} - else: - self.map = mapping - - self.lineno = None - self.option_seen = {} - self.version = version - -def _check_ksboolean(option, opt, value): - if value.lower() in ("on", "yes", "true", "1"): - return True - elif value.lower() in ("off", "no", "false", "0"): - return False - else: - mapping = {"opt": opt, "value": value} - raise OptionValueError(_("Option %(opt)s: invalid boolean value: %(value)r") % mapping) - -def _check_string(option, opt, value): - if len(value) > 2 and value.startswith("--"): - mapping = {"opt": opt, "value": value} - raise OptionValueError(_("Option %(opt)s: invalid string value: %(value)r") % mapping) - else: - return value - -# Creates a new Option class that supports several new attributes: -# - required: any option with this attribute must be supplied or an exception -# is thrown -# - introduced: the kickstart syntax version that this option first appeared -# in - an exception will be raised if the option is used and -# the specified syntax version is less than the value of this -# attribute -# - deprecated: the kickstart syntax version that this option was deprecated -# in - a DeprecationWarning will be thrown if the option is -# used and the specified syntax version is greater than the -# value of this attribute -# - removed: the kickstart syntax version that this option was removed in - an -# exception will be raised if the option is used and the specified -# syntax version is greated than the value of this attribute -# Also creates a new type: -# - ksboolean: support various kinds of boolean values on an option -# And two new actions: -# - map : allows you to define an opt -> val mapping such that dest gets val -# when opt is seen -# - map_extend: allows you to define an opt -> [val1, ... valn] mapping such -# that dest gets a list of vals built up when opt is seen -class KSOption (Option): - ATTRS = Option.ATTRS + ['introduced', 'deprecated', 'removed', 'required'] - ACTIONS = Option.ACTIONS + ("map", "map_extend",) - STORE_ACTIONS = Option.STORE_ACTIONS + ("map", "map_extend",) - - TYPES = Option.TYPES + ("ksboolean", "string") - TYPE_CHECKER = copy(Option.TYPE_CHECKER) - TYPE_CHECKER["ksboolean"] = _check_ksboolean - TYPE_CHECKER["string"] = _check_string - - def _check_required(self): - if self.required and not self.takes_value(): - raise OptionError(_("Required flag set for option that doesn't take a value"), self) - - # Make sure _check_required() is called from the constructor! - CHECK_METHODS = Option.CHECK_METHODS + [_check_required] - - def process (self, opt, value, values, parser): - Option.process(self, opt, value, values, parser) - parser.option_seen[self] = 1 - - # Override default take_action method to handle our custom actions. - def take_action(self, action, dest, opt, value, values, parser): - if action == "map": - values.ensure_value(dest, parser.map[opt.lstrip('-')]) - elif action == "map_extend": - values.ensure_value(dest, []).extend(parser.map[opt.lstrip('-')]) - else: - Option.take_action(self, action, dest, opt, value, values, parser) - - def takes_value(self): - # Deprecated options don't take a value. - return Option.takes_value(self) and not self.deprecated - - def __init__(self, *args, **kwargs): - self.deprecated = False - self.required = False - Option.__init__(self, *args, **kwargs) diff --git a/scripts/lib/mic/3rdparty/pykickstart/parser.py b/scripts/lib/mic/3rdparty/pykickstart/parser.py deleted file mode 100644 index 840a448673..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/parser.py +++ /dev/null @@ -1,702 +0,0 @@ -# -# parser.py: Kickstart file parser. -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2005, 2006, 2007, 2008, 2011 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -""" -Main kickstart file processing module. - -This module exports several important classes: - - Script - Representation of a single %pre, %post, or %traceback script. - - Packages - Representation of the %packages section. - - KickstartParser - The kickstart file parser state machine. -""" - -from collections import Iterator -import os -import shlex -import sys -import tempfile -from copy import copy -from optparse import * -from urlgrabber import urlread -import urlgrabber.grabber as grabber - -import constants -from errors import KickstartError, KickstartParseError, KickstartValueError, formatErrorMsg -from ko import KickstartObject -from sections import * -import version - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -STATE_END = "end" -STATE_COMMANDS = "commands" - -ver = version.DEVEL - -def _preprocessStateMachine (lineIter): - l = None - lineno = 0 - - # Now open an output kickstart file that we are going to write to one - # line at a time. - (outF, outName) = tempfile.mkstemp("-ks.cfg", "", "/tmp") - - while True: - try: - l = lineIter.next() - except StopIteration: - break - - # At the end of the file? - if l == "": - break - - lineno += 1 - url = None - - ll = l.strip() - if not ll.startswith("%ksappend"): - os.write(outF, l) - continue - - # Try to pull down the remote file. - try: - ksurl = ll.split(' ')[1] - except: - raise KickstartParseError, formatErrorMsg(lineno, msg=_("Illegal url for %%ksappend: %s") % ll) - - try: - url = grabber.urlopen(ksurl) - except grabber.URLGrabError, e: - raise KickstartError, formatErrorMsg(lineno, msg=_("Unable to open %%ksappend file: %s") % e.strerror) - else: - # Sanity check result. Sometimes FTP doesn't catch a file - # is missing. - try: - if url.size < 1: - raise KickstartError, formatErrorMsg(lineno, msg=_("Unable to open %%ksappend file")) - except: - raise KickstartError, formatErrorMsg(lineno, msg=_("Unable to open %%ksappend file")) - - # If that worked, write the remote file to the output kickstart - # file in one burst. Then close everything up to get ready to - # read ahead in the input file. This allows multiple %ksappend - # lines to exist. - if url is not None: - os.write(outF, url.read()) - url.close() - - # All done - close the temp file and return its location. - os.close(outF) - return outName - -def preprocessFromString (s): - """Preprocess the kickstart file, provided as the string str. This - method is currently only useful for handling %ksappend lines, - which need to be fetched before the real kickstart parser can be - run. Returns the location of the complete kickstart file. - """ - i = iter(s.splitlines(True) + [""]) - rc = _preprocessStateMachine (i.next) - return rc - -def preprocessKickstart (f): - """Preprocess the kickstart file, given by the filename file. This - method is currently only useful for handling %ksappend lines, - which need to be fetched before the real kickstart parser can be - run. Returns the location of the complete kickstart file. - """ - try: - fh = urlopen(f) - except grabber.URLGrabError, e: - raise KickstartError, formatErrorMsg(0, msg=_("Unable to open input kickstart file: %s") % e.strerror) - - rc = _preprocessStateMachine (iter(fh.readlines())) - fh.close() - return rc - -class PutBackIterator(Iterator): - def __init__(self, iterable): - self._iterable = iter(iterable) - self._buf = None - - def __iter__(self): - return self - - def put(self, s): - self._buf = s - - def next(self): - if self._buf: - retval = self._buf - self._buf = None - return retval - else: - return self._iterable.next() - -### -### SCRIPT HANDLING -### -class Script(KickstartObject): - """A class representing a single kickstart script. If functionality beyond - just a data representation is needed (for example, a run method in - anaconda), Script may be subclassed. Although a run method is not - provided, most of the attributes of Script have to do with running the - script. Instances of Script are held in a list by the Version object. - """ - def __init__(self, script, *args , **kwargs): - """Create a new Script instance. Instance attributes: - - errorOnFail -- If execution of the script fails, should anaconda - stop, display an error, and then reboot without - running any other scripts? - inChroot -- Does the script execute in anaconda's chroot - environment or not? - interp -- The program that should be used to interpret this - script. - lineno -- The line number this script starts on. - logfile -- Where all messages from the script should be logged. - script -- A string containing all the lines of the script. - type -- The type of the script, which can be KS_SCRIPT_* from - pykickstart.constants. - """ - KickstartObject.__init__(self, *args, **kwargs) - self.script = "".join(script) - - self.interp = kwargs.get("interp", "/bin/sh") - self.inChroot = kwargs.get("inChroot", False) - self.lineno = kwargs.get("lineno", None) - self.logfile = kwargs.get("logfile", None) - self.errorOnFail = kwargs.get("errorOnFail", False) - self.type = kwargs.get("type", constants.KS_SCRIPT_PRE) - - def __str__(self): - """Return a string formatted for output to a kickstart file.""" - retval = "" - - if self.type == constants.KS_SCRIPT_PRE: - retval += '\n%pre' - elif self.type == constants.KS_SCRIPT_POST: - retval += '\n%post' - elif self.type == constants.KS_SCRIPT_TRACEBACK: - retval += '\n%traceback' - - if self.interp != "/bin/sh" and self.interp != "": - retval += " --interpreter=%s" % self.interp - if self.type == constants.KS_SCRIPT_POST and not self.inChroot: - retval += " --nochroot" - if self.logfile != None: - retval += " --logfile %s" % self.logfile - if self.errorOnFail: - retval += " --erroronfail" - - if self.script.endswith("\n"): - if ver >= version.F8: - return retval + "\n%s%%end\n" % self.script - else: - return retval + "\n%s\n" % self.script - else: - if ver >= version.F8: - return retval + "\n%s\n%%end\n" % self.script - else: - return retval + "\n%s\n" % self.script - - -## -## PACKAGE HANDLING -## -class Group: - """A class representing a single group in the %packages section.""" - def __init__(self, name="", include=constants.GROUP_DEFAULT): - """Create a new Group instance. Instance attributes: - - name -- The group's identifier - include -- The level of how much of the group should be included. - Values can be GROUP_* from pykickstart.constants. - """ - self.name = name - self.include = include - - def __str__(self): - """Return a string formatted for output to a kickstart file.""" - if self.include == constants.GROUP_REQUIRED: - return "@%s --nodefaults" % self.name - elif self.include == constants.GROUP_ALL: - return "@%s --optional" % self.name - else: - return "@%s" % self.name - - def __cmp__(self, other): - if self.name < other.name: - return -1 - elif self.name > other.name: - return 1 - return 0 - -class Packages(KickstartObject): - """A class representing the %packages section of the kickstart file.""" - def __init__(self, *args, **kwargs): - """Create a new Packages instance. Instance attributes: - - addBase -- Should the Base group be installed even if it is - not specified? - default -- Should the default package set be selected? - excludedList -- A list of all the packages marked for exclusion in - the %packages section, without the leading minus - symbol. - excludeDocs -- Should documentation in each package be excluded? - groupList -- A list of Group objects representing all the groups - specified in the %packages section. Names will be - stripped of the leading @ symbol. - excludedGroupList -- A list of Group objects representing all the - groups specified for removal in the %packages - section. Names will be stripped of the leading - -@ symbols. - handleMissing -- If unknown packages are specified in the %packages - section, should it be ignored or not? Values can - be KS_MISSING_* from pykickstart.constants. - packageList -- A list of all the packages specified in the - %packages section. - instLangs -- A list of languages to install. - """ - KickstartObject.__init__(self, *args, **kwargs) - - self.addBase = True - self.default = False - self.excludedList = [] - self.excludedGroupList = [] - self.excludeDocs = False - self.groupList = [] - self.handleMissing = constants.KS_MISSING_PROMPT - self.packageList = [] - self.instLangs = None - - def __str__(self): - """Return a string formatted for output to a kickstart file.""" - pkgs = "" - - if not self.default: - grps = self.groupList - grps.sort() - for grp in grps: - pkgs += "%s\n" % grp.__str__() - - p = self.packageList - p.sort() - for pkg in p: - pkgs += "%s\n" % pkg - - grps = self.excludedGroupList - grps.sort() - for grp in grps: - pkgs += "-%s\n" % grp.__str__() - - p = self.excludedList - p.sort() - for pkg in p: - pkgs += "-%s\n" % pkg - - if pkgs == "": - return "" - - retval = "\n%packages" - - if self.default: - retval += " --default" - if self.excludeDocs: - retval += " --excludedocs" - if not self.addBase: - retval += " --nobase" - if self.handleMissing == constants.KS_MISSING_IGNORE: - retval += " --ignoremissing" - if self.instLangs: - retval += " --instLangs=%s" % self.instLangs - - if ver >= version.F8: - return retval + "\n" + pkgs + "\n%end\n" - else: - return retval + "\n" + pkgs + "\n" - - def _processGroup (self, line): - op = OptionParser() - op.add_option("--nodefaults", action="store_true", default=False) - op.add_option("--optional", action="store_true", default=False) - - (opts, extra) = op.parse_args(args=line.split()) - - if opts.nodefaults and opts.optional: - raise KickstartValueError, _("Group cannot specify both --nodefaults and --optional") - - # If the group name has spaces in it, we have to put it back together - # now. - grp = " ".join(extra) - - if opts.nodefaults: - self.groupList.append(Group(name=grp, include=constants.GROUP_REQUIRED)) - elif opts.optional: - self.groupList.append(Group(name=grp, include=constants.GROUP_ALL)) - else: - self.groupList.append(Group(name=grp, include=constants.GROUP_DEFAULT)) - - def add (self, pkgList): - """Given a list of lines from the input file, strip off any leading - symbols and add the result to the appropriate list. - """ - existingExcludedSet = set(self.excludedList) - existingPackageSet = set(self.packageList) - newExcludedSet = set() - newPackageSet = set() - - excludedGroupList = [] - - for pkg in pkgList: - stripped = pkg.strip() - - if stripped[0] == "@": - self._processGroup(stripped[1:]) - elif stripped[0] == "-": - if stripped[1] == "@": - excludedGroupList.append(Group(name=stripped[2:])) - else: - newExcludedSet.add(stripped[1:]) - else: - newPackageSet.add(stripped) - - # Groups have to be excluded in two different ways (note: can't use - # sets here because we have to store objects): - excludedGroupNames = map(lambda g: g.name, excludedGroupList) - - # First, an excluded group may be cancelling out a previously given - # one. This is often the case when using %include. So there we should - # just remove the group from the list. - self.groupList = filter(lambda g: g.name not in excludedGroupNames, self.groupList) - - # Second, the package list could have included globs which are not - # processed by pykickstart. In that case we need to preserve a list of - # excluded groups so whatever tool doing package/group installation can - # take appropriate action. - self.excludedGroupList.extend(excludedGroupList) - - existingPackageSet = (existingPackageSet - newExcludedSet) | newPackageSet - existingExcludedSet = (existingExcludedSet - existingPackageSet) | newExcludedSet - - self.packageList = list(existingPackageSet) - self.excludedList = list(existingExcludedSet) - - -### -### PARSER -### -class KickstartParser: - """The kickstart file parser class as represented by a basic state - machine. To create a specialized parser, make a subclass and override - any of the methods you care about. Methods that don't need to do - anything may just pass. However, _stateMachine should never be - overridden. - """ - def __init__ (self, handler, followIncludes=True, errorsAreFatal=True, - missingIncludeIsFatal=True): - """Create a new KickstartParser instance. Instance attributes: - - errorsAreFatal -- Should errors cause processing to halt, or - just print a message to the screen? This - is most useful for writing syntax checkers - that may want to continue after an error is - encountered. - followIncludes -- If %include is seen, should the included - file be checked as well or skipped? - handler -- An instance of a BaseHandler subclass. If - None, the input file will still be parsed - but no data will be saved and no commands - will be executed. - missingIncludeIsFatal -- Should missing include files be fatal, even - if errorsAreFatal is False? - """ - self.errorsAreFatal = errorsAreFatal - self.followIncludes = followIncludes - self.handler = handler - self.currentdir = {} - self.missingIncludeIsFatal = missingIncludeIsFatal - - self._state = STATE_COMMANDS - self._includeDepth = 0 - self._line = "" - - self.version = self.handler.version - - global ver - ver = self.version - - self._sections = {} - self.setupSections() - - def _reset(self): - """Reset the internal variables of the state machine for a new kickstart file.""" - self._state = STATE_COMMANDS - self._includeDepth = 0 - - def getSection(self, s): - """Return a reference to the requested section (s must start with '%'s), - or raise KeyError if not found. - """ - return self._sections[s] - - def handleCommand (self, lineno, args): - """Given the list of command and arguments, call the Version's - dispatcher method to handle the command. Returns the command or - data object returned by the dispatcher. This method may be - overridden in a subclass if necessary. - """ - if self.handler: - self.handler.currentCmd = args[0] - self.handler.currentLine = self._line - retval = self.handler.dispatcher(args, lineno) - - return retval - - def registerSection(self, obj): - """Given an instance of a Section subclass, register the new section - with the parser. Calling this method means the parser will - recognize your new section and dispatch into the given object to - handle it. - """ - if not obj.sectionOpen: - raise TypeError, "no sectionOpen given for section %s" % obj - - if not obj.sectionOpen.startswith("%"): - raise TypeError, "section %s tag does not start with a %%" % obj.sectionOpen - - self._sections[obj.sectionOpen] = obj - - def _finalize(self, obj): - """Called at the close of a kickstart section to take any required - actions. Internally, this is used to add scripts once we have the - whole body read. - """ - obj.finalize() - self._state = STATE_COMMANDS - - def _handleSpecialComments(self, line): - """Kickstart recognizes a couple special comments.""" - if self._state != STATE_COMMANDS: - return - - # Save the platform for s-c-kickstart. - if line[:10] == "#platform=": - self.handler.platform = self._line[11:] - - def _readSection(self, lineIter, lineno): - obj = self._sections[self._state] - - while True: - try: - line = lineIter.next() - if line == "": - # This section ends at the end of the file. - if self.version >= version.F8: - raise KickstartParseError, formatErrorMsg(lineno, msg=_("Section does not end with %%end.")) - - self._finalize(obj) - except StopIteration: - break - - lineno += 1 - - # Throw away blank lines and comments, unless the section wants all - # lines. - if self._isBlankOrComment(line) and not obj.allLines: - continue - - if line.startswith("%"): - args = shlex.split(line) - - if args and args[0] == "%end": - # This is a properly terminated section. - self._finalize(obj) - break - elif args and args[0] == "%ksappend": - continue - elif args and (self._validState(args[0]) or args[0] in ["%include", "%ksappend"]): - # This is an unterminated section. - if self.version >= version.F8: - raise KickstartParseError, formatErrorMsg(lineno, msg=_("Section does not end with %%end.")) - - # Finish up. We do not process the header here because - # kicking back out to STATE_COMMANDS will ensure that happens. - lineIter.put(line) - lineno -= 1 - self._finalize(obj) - break - else: - # This is just a line within a section. Pass it off to whatever - # section handles it. - obj.handleLine(line) - - return lineno - - def _validState(self, st): - """Is the given section tag one that has been registered with the parser?""" - return st in self._sections.keys() - - def _tryFunc(self, fn): - """Call the provided function (which doesn't take any arguments) and - do the appropriate error handling. If errorsAreFatal is False, this - function will just print the exception and keep going. - """ - try: - fn() - except Exception, msg: - if self.errorsAreFatal: - raise - else: - print msg - - def _isBlankOrComment(self, line): - return line.isspace() or line == "" or line.lstrip()[0] == '#' - - def _stateMachine(self, lineIter): - # For error reporting. - lineno = 0 - - while True: - # Get the next line out of the file, quitting if this is the last line. - try: - self._line = lineIter.next() - if self._line == "": - break - except StopIteration: - break - - lineno += 1 - - # Eliminate blank lines, whitespace-only lines, and comments. - if self._isBlankOrComment(self._line): - self._handleSpecialComments(self._line) - continue - - # Remove any end-of-line comments. - sanitized = self._line.split("#")[0] - - # Then split the line. - args = shlex.split(sanitized.rstrip()) - - if args[0] == "%include": - # This case comes up primarily in ksvalidator. - if not self.followIncludes: - continue - - if len(args) == 1 or not args[1]: - raise KickstartParseError, formatErrorMsg(lineno) - - self._includeDepth += 1 - - try: - self.readKickstart(args[1], reset=False) - except KickstartError: - # Handle the include file being provided over the - # network in a %pre script. This case comes up in the - # early parsing in anaconda. - if self.missingIncludeIsFatal: - raise - - self._includeDepth -= 1 - continue - - # Now on to the main event. - if self._state == STATE_COMMANDS: - if args[0] == "%ksappend": - # This is handled by the preprocess* functions, so continue. - continue - elif args[0][0] == '%': - # This is the beginning of a new section. Handle its header - # here. - newSection = args[0] - if not self._validState(newSection): - raise KickstartParseError, formatErrorMsg(lineno, msg=_("Unknown kickstart section: %s" % newSection)) - - self._state = newSection - obj = self._sections[self._state] - self._tryFunc(lambda: obj.handleHeader(lineno, args)) - - # This will handle all section processing, kicking us back - # out to STATE_COMMANDS at the end with the current line - # being the next section header, etc. - lineno = self._readSection(lineIter, lineno) - else: - # This is a command in the command section. Dispatch to it. - self._tryFunc(lambda: self.handleCommand(lineno, args)) - elif self._state == STATE_END: - break - - def readKickstartFromString (self, s, reset=True): - """Process a kickstart file, provided as the string str.""" - if reset: - self._reset() - - # Add a "" to the end of the list so the string reader acts like the - # file reader and we only get StopIteration when we're after the final - # line of input. - i = PutBackIterator(s.splitlines(True) + [""]) - self._stateMachine (i) - - def readKickstart(self, f, reset=True): - """Process a kickstart file, given by the filename f.""" - if reset: - self._reset() - - # an %include might not specify a full path. if we don't try to figure - # out what the path should have been, then we're unable to find it - # requiring full path specification, though, sucks. so let's make - # the reading "smart" by keeping track of what the path is at each - # include depth. - if not os.path.exists(f): - if self.currentdir.has_key(self._includeDepth - 1): - if os.path.exists(os.path.join(self.currentdir[self._includeDepth - 1], f)): - f = os.path.join(self.currentdir[self._includeDepth - 1], f) - - cd = os.path.dirname(f) - if not cd.startswith("/"): - cd = os.path.abspath(cd) - self.currentdir[self._includeDepth] = cd - - try: - s = urlread(f) - except grabber.URLGrabError, e: - raise KickstartError, formatErrorMsg(0, msg=_("Unable to open input kickstart file: %s") % e.strerror) - - self.readKickstartFromString(s, reset=False) - - def setupSections(self): - """Install the sections all kickstart files support. You may override - this method in a subclass, but should avoid doing so unless you know - what you're doing. - """ - self._sections = {} - - # Install the sections all kickstart files support. - self.registerSection(PreScriptSection(self.handler, dataObj=Script)) - self.registerSection(PostScriptSection(self.handler, dataObj=Script)) - self.registerSection(TracebackScriptSection(self.handler, dataObj=Script)) - self.registerSection(PackageSection(self.handler)) diff --git a/scripts/lib/mic/3rdparty/pykickstart/sections.py b/scripts/lib/mic/3rdparty/pykickstart/sections.py deleted file mode 100644 index 44df856b8d..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/sections.py +++ /dev/null @@ -1,244 +0,0 @@ -# -# sections.py: Kickstart file sections. -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2011 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -""" -This module exports the classes that define a section of a kickstart file. A -section is a chunk of the file starting with a %tag and ending with a %end. -Examples of sections include %packages, %pre, and %post. - -You may use this module to define your own custom sections which will be -treated just the same as a predefined one by the kickstart parser. All that -is necessary is to create a new subclass of Section and call -parser.registerSection with an instance of your new class. -""" -from constants import * -from options import KSOptionParser -from version import * - -class Section(object): - """The base class for defining kickstart sections. You are free to - subclass this as appropriate. - - Class attributes: - - allLines -- Does this section require the parser to call handleLine - for every line in the section, even blanks and comments? - sectionOpen -- The string that denotes the start of this section. You - must start your tag with a percent sign. - timesSeen -- This attribute is for informational purposes only. It is - incremented every time handleHeader is called to keep - track of the number of times a section of this type is - seen. - """ - allLines = False - sectionOpen = "" - timesSeen = 0 - - def __init__(self, handler, **kwargs): - """Create a new Script instance. At the least, you must pass in an - instance of a baseHandler subclass. - - Valid kwargs: - - dataObj -- - """ - self.handler = handler - - self.version = self.handler.version - - self.dataObj = kwargs.get("dataObj", None) - - def finalize(self): - """This method is called when the %end tag for a section is seen. It - is not required to be provided. - """ - pass - - def handleLine(self, line): - """This method is called for every line of a section. Take whatever - action is appropriate. While this method is not required to be - provided, not providing it does not make a whole lot of sense. - - Arguments: - - line -- The complete line, with any trailing newline. - """ - pass - - def handleHeader(self, lineno, args): - """This method is called when the opening tag for a section is seen. - Not all sections will need this method, though all provided with - kickstart include one. - - Arguments: - - args -- A list of all strings passed as arguments to the section - opening tag. - """ - self.timesSeen += 1 - -class NullSection(Section): - """This defines a section that pykickstart will recognize but do nothing - with. If the parser runs across a %section that has no object registered, - it will raise an error. Sometimes, you may want to simply ignore those - sections instead. This class is useful for that purpose. - """ - def __init__(self, *args, **kwargs): - """Create a new NullSection instance. You must pass a sectionOpen - parameter (including a leading '%') for the section you wish to - ignore. - """ - Section.__init__(self, *args, **kwargs) - self.sectionOpen = kwargs.get("sectionOpen") - -class ScriptSection(Section): - allLines = True - - def __init__(self, *args, **kwargs): - Section.__init__(self, *args, **kwargs) - self._script = {} - self._resetScript() - - def _getParser(self): - op = KSOptionParser(self.version) - op.add_option("--erroronfail", dest="errorOnFail", action="store_true", - default=False) - op.add_option("--interpreter", dest="interpreter", default="/bin/sh") - op.add_option("--log", "--logfile", dest="log") - return op - - def _resetScript(self): - self._script = {"interp": "/bin/sh", "log": None, "errorOnFail": False, - "lineno": None, "chroot": False, "body": []} - - def handleLine(self, line): - self._script["body"].append(line) - - def finalize(self): - if " ".join(self._script["body"]).strip() == "": - return - - kwargs = {"interp": self._script["interp"], - "inChroot": self._script["chroot"], - "lineno": self._script["lineno"], - "logfile": self._script["log"], - "errorOnFail": self._script["errorOnFail"], - "type": self._script["type"]} - - s = self.dataObj (self._script["body"], **kwargs) - self._resetScript() - - if self.handler: - self.handler.scripts.append(s) - - def handleHeader(self, lineno, args): - """Process the arguments to a %pre/%post/%traceback header for later - setting on a Script instance once the end of the script is found. - This method may be overridden in a subclass if necessary. - """ - Section.handleHeader(self, lineno, args) - op = self._getParser() - - (opts, extra) = op.parse_args(args=args[1:], lineno=lineno) - - self._script["interp"] = opts.interpreter - self._script["lineno"] = lineno - self._script["log"] = opts.log - self._script["errorOnFail"] = opts.errorOnFail - if hasattr(opts, "nochroot"): - self._script["chroot"] = not opts.nochroot - -class PreScriptSection(ScriptSection): - sectionOpen = "%pre" - - def _resetScript(self): - ScriptSection._resetScript(self) - self._script["type"] = KS_SCRIPT_PRE - -class PostScriptSection(ScriptSection): - sectionOpen = "%post" - - def _getParser(self): - op = ScriptSection._getParser(self) - op.add_option("--nochroot", dest="nochroot", action="store_true", - default=False) - return op - - def _resetScript(self): - ScriptSection._resetScript(self) - self._script["chroot"] = True - self._script["type"] = KS_SCRIPT_POST - -class TracebackScriptSection(ScriptSection): - sectionOpen = "%traceback" - - def _resetScript(self): - ScriptSection._resetScript(self) - self._script["type"] = KS_SCRIPT_TRACEBACK - -class PackageSection(Section): - sectionOpen = "%packages" - - def handleLine(self, line): - if not self.handler: - return - - (h, s, t) = line.partition('#') - line = h.rstrip() - - self.handler.packages.add([line]) - - def handleHeader(self, lineno, args): - """Process the arguments to the %packages header and set attributes - on the Version's Packages instance appropriate. This method may be - overridden in a subclass if necessary. - """ - Section.handleHeader(self, lineno, args) - op = KSOptionParser(version=self.version) - op.add_option("--excludedocs", dest="excludedocs", action="store_true", - default=False) - op.add_option("--ignoremissing", dest="ignoremissing", - action="store_true", default=False) - op.add_option("--nobase", dest="nobase", action="store_true", - default=False) - op.add_option("--ignoredeps", dest="resolveDeps", action="store_false", - deprecated=FC4, removed=F9) - op.add_option("--resolvedeps", dest="resolveDeps", action="store_true", - deprecated=FC4, removed=F9) - op.add_option("--default", dest="defaultPackages", action="store_true", - default=False, introduced=F7) - op.add_option("--instLangs", dest="instLangs", type="string", - default="", introduced=F9) - - (opts, extra) = op.parse_args(args=args[1:], lineno=lineno) - - self.handler.packages.excludeDocs = opts.excludedocs - self.handler.packages.addBase = not opts.nobase - if opts.ignoremissing: - self.handler.packages.handleMissing = KS_MISSING_IGNORE - else: - self.handler.packages.handleMissing = KS_MISSING_PROMPT - - if opts.defaultPackages: - self.handler.packages.default = True - - if opts.instLangs: - self.handler.packages.instLangs = opts.instLangs diff --git a/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/__init__.py b/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/__init__.py deleted file mode 100644 index 7bcd9d5541..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/__init__.py +++ /dev/null @@ -1,53 +0,0 @@ -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2 of the License, or -# (at your option) any later version. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU Library General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -# Copyright 2002-2006 Michael D. Stenner, Ryan Tomayko - -# $Id: __init__.py,v 1.20 2006/09/22 00:58:55 mstenner Exp $ - -"""A high-level cross-protocol url-grabber. - -Using urlgrabber, data can be fetched in three basic ways: - - urlgrab(url) copy the file to the local filesystem - urlopen(url) open the remote file and return a file object - (like urllib2.urlopen) - urlread(url) return the contents of the file as a string - -When using these functions (or methods), urlgrabber supports the -following features: - - * identical behavior for http://, ftp://, and file:// urls - * http keepalive - faster downloads of many files by using - only a single connection - * byte ranges - fetch only a portion of the file - * reget - for a urlgrab, resume a partial download - * progress meters - the ability to report download progress - automatically, even when using urlopen! - * throttling - restrict bandwidth usage - * retries - automatically retry a download if it fails. The - number of retries and failure types are configurable. - * authenticated server access for http and ftp - * proxy support - support for authenticated http and ftp proxies - * mirror groups - treat a list of mirrors as a single source, - automatically switching mirrors if there is a failure. -""" - -__version__ = '3.1.0' -__date__ = '2006/09/21' -__author__ = 'Michael D. Stenner <mstenner@linux.duke.edu>, ' \ - 'Ryan Tomayko <rtomayko@naeblis.cx>' -__url__ = 'http://linux.duke.edu/projects/urlgrabber/' - -from grabber import urlgrab, urlopen, urlread diff --git a/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/byterange.py b/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/byterange.py deleted file mode 100644 index 001b4e32d6..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/byterange.py +++ /dev/null @@ -1,463 +0,0 @@ -# This library is free software; you can redistribute it and/or -# modify it under the terms of the GNU Lesser General Public -# License as published by the Free Software Foundation; either -# version 2.1 of the License, or (at your option) any later version. -# -# This library is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Lesser General Public License for more details. -# -# You should have received a copy of the GNU Lesser General Public -# License along with this library; if not, write to the -# Free Software Foundation, Inc., -# 59 Temple Place, Suite 330, -# Boston, MA 02111-1307 USA - -# This file is part of urlgrabber, a high-level cross-protocol url-grabber -# Copyright 2002-2004 Michael D. Stenner, Ryan Tomayko - -# $Id: byterange.py,v 1.12 2006/07/20 20:15:58 mstenner Exp $ - -import os -import stat -import urllib -import urllib2 -import rfc822 - -DEBUG = None - -try: - from cStringIO import StringIO -except ImportError, msg: - from StringIO import StringIO - -class RangeError(IOError): - """Error raised when an unsatisfiable range is requested.""" - pass - -class HTTPRangeHandler(urllib2.BaseHandler): - """Handler that enables HTTP Range headers. - - This was extremely simple. The Range header is a HTTP feature to - begin with so all this class does is tell urllib2 that the - "206 Partial Content" reponse from the HTTP server is what we - expected. - - Example: - import urllib2 - import byterange - - range_handler = range.HTTPRangeHandler() - opener = urllib2.build_opener(range_handler) - - # install it - urllib2.install_opener(opener) - - # create Request and set Range header - req = urllib2.Request('http://www.python.org/') - req.header['Range'] = 'bytes=30-50' - f = urllib2.urlopen(req) - """ - - def http_error_206(self, req, fp, code, msg, hdrs): - # 206 Partial Content Response - r = urllib.addinfourl(fp, hdrs, req.get_full_url()) - r.code = code - r.msg = msg - return r - - def http_error_416(self, req, fp, code, msg, hdrs): - # HTTP's Range Not Satisfiable error - raise RangeError('Requested Range Not Satisfiable') - -class HTTPSRangeHandler(HTTPRangeHandler): - """ Range Header support for HTTPS. """ - - def https_error_206(self, req, fp, code, msg, hdrs): - return self.http_error_206(req, fp, code, msg, hdrs) - - def https_error_416(self, req, fp, code, msg, hdrs): - self.https_error_416(req, fp, code, msg, hdrs) - -class RangeableFileObject: - """File object wrapper to enable raw range handling. - This was implemented primarilary for handling range - specifications for file:// urls. This object effectively makes - a file object look like it consists only of a range of bytes in - the stream. - - Examples: - # expose 10 bytes, starting at byte position 20, from - # /etc/aliases. - >>> fo = RangeableFileObject(file('/etc/passwd', 'r'), (20,30)) - # seek seeks within the range (to position 23 in this case) - >>> fo.seek(3) - # tell tells where your at _within the range_ (position 3 in - # this case) - >>> fo.tell() - # read EOFs if an attempt is made to read past the last - # byte in the range. the following will return only 7 bytes. - >>> fo.read(30) - """ - - def __init__(self, fo, rangetup): - """Create a RangeableFileObject. - fo -- a file like object. only the read() method need be - supported but supporting an optimized seek() is - preferable. - rangetup -- a (firstbyte,lastbyte) tuple specifying the range - to work over. - The file object provided is assumed to be at byte offset 0. - """ - self.fo = fo - (self.firstbyte, self.lastbyte) = range_tuple_normalize(rangetup) - self.realpos = 0 - self._do_seek(self.firstbyte) - - def __getattr__(self, name): - """This effectively allows us to wrap at the instance level. - Any attribute not found in _this_ object will be searched for - in self.fo. This includes methods.""" - if hasattr(self.fo, name): - return getattr(self.fo, name) - raise AttributeError, name - - def tell(self): - """Return the position within the range. - This is different from fo.seek in that position 0 is the - first byte position of the range tuple. For example, if - this object was created with a range tuple of (500,899), - tell() will return 0 when at byte position 500 of the file. - """ - return (self.realpos - self.firstbyte) - - def seek(self,offset,whence=0): - """Seek within the byte range. - Positioning is identical to that described under tell(). - """ - assert whence in (0, 1, 2) - if whence == 0: # absolute seek - realoffset = self.firstbyte + offset - elif whence == 1: # relative seek - realoffset = self.realpos + offset - elif whence == 2: # absolute from end of file - # XXX: are we raising the right Error here? - raise IOError('seek from end of file not supported.') - - # do not allow seek past lastbyte in range - if self.lastbyte and (realoffset >= self.lastbyte): - realoffset = self.lastbyte - - self._do_seek(realoffset - self.realpos) - - def read(self, size=-1): - """Read within the range. - This method will limit the size read based on the range. - """ - size = self._calc_read_size(size) - rslt = self.fo.read(size) - self.realpos += len(rslt) - return rslt - - def readline(self, size=-1): - """Read lines within the range. - This method will limit the size read based on the range. - """ - size = self._calc_read_size(size) - rslt = self.fo.readline(size) - self.realpos += len(rslt) - return rslt - - def _calc_read_size(self, size): - """Handles calculating the amount of data to read based on - the range. - """ - if self.lastbyte: - if size > -1: - if ((self.realpos + size) >= self.lastbyte): - size = (self.lastbyte - self.realpos) - else: - size = (self.lastbyte - self.realpos) - return size - - def _do_seek(self,offset): - """Seek based on whether wrapped object supports seek(). - offset is relative to the current position (self.realpos). - """ - assert offset >= 0 - if not hasattr(self.fo, 'seek'): - self._poor_mans_seek(offset) - else: - self.fo.seek(self.realpos + offset) - self.realpos+= offset - - def _poor_mans_seek(self,offset): - """Seek by calling the wrapped file objects read() method. - This is used for file like objects that do not have native - seek support. The wrapped objects read() method is called - to manually seek to the desired position. - offset -- read this number of bytes from the wrapped - file object. - raise RangeError if we encounter EOF before reaching the - specified offset. - """ - pos = 0 - bufsize = 1024 - while pos < offset: - if (pos + bufsize) > offset: - bufsize = offset - pos - buf = self.fo.read(bufsize) - if len(buf) != bufsize: - raise RangeError('Requested Range Not Satisfiable') - pos+= bufsize - -class FileRangeHandler(urllib2.FileHandler): - """FileHandler subclass that adds Range support. - This class handles Range headers exactly like an HTTP - server would. - """ - def open_local_file(self, req): - import mimetypes - import mimetools - host = req.get_host() - file = req.get_selector() - localfile = urllib.url2pathname(file) - stats = os.stat(localfile) - size = stats[stat.ST_SIZE] - modified = rfc822.formatdate(stats[stat.ST_MTIME]) - mtype = mimetypes.guess_type(file)[0] - if host: - host, port = urllib.splitport(host) - if port or socket.gethostbyname(host) not in self.get_names(): - raise urllib2.URLError('file not on local host') - fo = open(localfile,'rb') - brange = req.headers.get('Range',None) - brange = range_header_to_tuple(brange) - assert brange != () - if brange: - (fb,lb) = brange - if lb == '': lb = size - if fb < 0 or fb > size or lb > size: - raise RangeError('Requested Range Not Satisfiable') - size = (lb - fb) - fo = RangeableFileObject(fo, (fb,lb)) - headers = mimetools.Message(StringIO( - 'Content-Type: %s\nContent-Length: %d\nLast-modified: %s\n' % - (mtype or 'text/plain', size, modified))) - return urllib.addinfourl(fo, headers, 'file:'+file) - - -# FTP Range Support -# Unfortunately, a large amount of base FTP code had to be copied -# from urllib and urllib2 in order to insert the FTP REST command. -# Code modifications for range support have been commented as -# follows: -# -- range support modifications start/end here - -from urllib import splitport, splituser, splitpasswd, splitattr, \ - unquote, addclosehook, addinfourl -import ftplib -import socket -import sys -import ftplib -import mimetypes -import mimetools - -class FTPRangeHandler(urllib2.FTPHandler): - def ftp_open(self, req): - host = req.get_host() - if not host: - raise IOError, ('ftp error', 'no host given') - host, port = splitport(host) - if port is None: - port = ftplib.FTP_PORT - - # username/password handling - user, host = splituser(host) - if user: - user, passwd = splitpasswd(user) - else: - passwd = None - host = unquote(host) - user = unquote(user or '') - passwd = unquote(passwd or '') - - try: - host = socket.gethostbyname(host) - except socket.error, msg: - raise urllib2.URLError(msg) - path, attrs = splitattr(req.get_selector()) - dirs = path.split('/') - dirs = map(unquote, dirs) - dirs, file = dirs[:-1], dirs[-1] - if dirs and not dirs[0]: - dirs = dirs[1:] - try: - fw = self.connect_ftp(user, passwd, host, port, dirs) - type = file and 'I' or 'D' - for attr in attrs: - attr, value = splitattr(attr) - if attr.lower() == 'type' and \ - value in ('a', 'A', 'i', 'I', 'd', 'D'): - type = value.upper() - - # -- range support modifications start here - rest = None - range_tup = range_header_to_tuple(req.headers.get('Range',None)) - assert range_tup != () - if range_tup: - (fb,lb) = range_tup - if fb > 0: rest = fb - # -- range support modifications end here - - fp, retrlen = fw.retrfile(file, type, rest) - - # -- range support modifications start here - if range_tup: - (fb,lb) = range_tup - if lb == '': - if retrlen is None or retrlen == 0: - raise RangeError('Requested Range Not Satisfiable due to unobtainable file length.') - lb = retrlen - retrlen = lb - fb - if retrlen < 0: - # beginning of range is larger than file - raise RangeError('Requested Range Not Satisfiable') - else: - retrlen = lb - fb - fp = RangeableFileObject(fp, (0,retrlen)) - # -- range support modifications end here - - headers = "" - mtype = mimetypes.guess_type(req.get_full_url())[0] - if mtype: - headers += "Content-Type: %s\n" % mtype - if retrlen is not None and retrlen >= 0: - headers += "Content-Length: %d\n" % retrlen - sf = StringIO(headers) - headers = mimetools.Message(sf) - return addinfourl(fp, headers, req.get_full_url()) - except ftplib.all_errors, msg: - raise IOError, ('ftp error', msg), sys.exc_info()[2] - - def connect_ftp(self, user, passwd, host, port, dirs): - fw = ftpwrapper(user, passwd, host, port, dirs) - return fw - -class ftpwrapper(urllib.ftpwrapper): - # range support note: - # this ftpwrapper code is copied directly from - # urllib. The only enhancement is to add the rest - # argument and pass it on to ftp.ntransfercmd - def retrfile(self, file, type, rest=None): - self.endtransfer() - if type in ('d', 'D'): cmd = 'TYPE A'; isdir = 1 - else: cmd = 'TYPE ' + type; isdir = 0 - try: - self.ftp.voidcmd(cmd) - except ftplib.all_errors: - self.init() - self.ftp.voidcmd(cmd) - conn = None - if file and not isdir: - # Use nlst to see if the file exists at all - try: - self.ftp.nlst(file) - except ftplib.error_perm, reason: - raise IOError, ('ftp error', reason), sys.exc_info()[2] - # Restore the transfer mode! - self.ftp.voidcmd(cmd) - # Try to retrieve as a file - try: - cmd = 'RETR ' + file - conn = self.ftp.ntransfercmd(cmd, rest) - except ftplib.error_perm, reason: - if str(reason)[:3] == '501': - # workaround for REST not supported error - fp, retrlen = self.retrfile(file, type) - fp = RangeableFileObject(fp, (rest,'')) - return (fp, retrlen) - elif str(reason)[:3] != '550': - raise IOError, ('ftp error', reason), sys.exc_info()[2] - if not conn: - # Set transfer mode to ASCII! - self.ftp.voidcmd('TYPE A') - # Try a directory listing - if file: cmd = 'LIST ' + file - else: cmd = 'LIST' - conn = self.ftp.ntransfercmd(cmd) - self.busy = 1 - # Pass back both a suitably decorated object and a retrieval length - return (addclosehook(conn[0].makefile('rb'), - self.endtransfer), conn[1]) - - -#################################################################### -# Range Tuple Functions -# XXX: These range tuple functions might go better in a class. - -_rangere = None -def range_header_to_tuple(range_header): - """Get a (firstbyte,lastbyte) tuple from a Range header value. - - Range headers have the form "bytes=<firstbyte>-<lastbyte>". This - function pulls the firstbyte and lastbyte values and returns - a (firstbyte,lastbyte) tuple. If lastbyte is not specified in - the header value, it is returned as an empty string in the - tuple. - - Return None if range_header is None - Return () if range_header does not conform to the range spec - pattern. - - """ - global _rangere - if range_header is None: return None - if _rangere is None: - import re - _rangere = re.compile(r'^bytes=(\d{1,})-(\d*)') - match = _rangere.match(range_header) - if match: - tup = range_tuple_normalize(match.group(1,2)) - if tup and tup[1]: - tup = (tup[0],tup[1]+1) - return tup - return () - -def range_tuple_to_header(range_tup): - """Convert a range tuple to a Range header value. - Return a string of the form "bytes=<firstbyte>-<lastbyte>" or None - if no range is needed. - """ - if range_tup is None: return None - range_tup = range_tuple_normalize(range_tup) - if range_tup: - if range_tup[1]: - range_tup = (range_tup[0],range_tup[1] - 1) - return 'bytes=%s-%s' % range_tup - -def range_tuple_normalize(range_tup): - """Normalize a (first_byte,last_byte) range tuple. - Return a tuple whose first element is guaranteed to be an int - and whose second element will be '' (meaning: the last byte) or - an int. Finally, return None if the normalized tuple == (0,'') - as that is equivelant to retrieving the entire file. - """ - if range_tup is None: return None - # handle first byte - fb = range_tup[0] - if fb in (None,''): fb = 0 - else: fb = int(fb) - # handle last byte - try: lb = range_tup[1] - except IndexError: lb = '' - else: - if lb is None: lb = '' - elif lb != '': lb = int(lb) - # check if range is over the entire file - if (fb,lb) == (0,''): return None - # check that the range is valid - if lb < fb: raise RangeError('Invalid byte range: %s-%s' % (fb,lb)) - return (fb,lb) - diff --git a/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/grabber.py b/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/grabber.py deleted file mode 100644 index fefdab36f6..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/grabber.py +++ /dev/null @@ -1,1477 +0,0 @@ -# This library is free software; you can redistribute it and/or -# modify it under the terms of the GNU Lesser General Public -# License as published by the Free Software Foundation; either -# version 2.1 of the License, or (at your option) any later version. -# -# This library is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Lesser General Public License for more details. -# -# You should have received a copy of the GNU Lesser General Public -# License along with this library; if not, write to the -# Free Software Foundation, Inc., -# 59 Temple Place, Suite 330, -# Boston, MA 02111-1307 USA - -# This file is part of urlgrabber, a high-level cross-protocol url-grabber -# Copyright 2002-2004 Michael D. Stenner, Ryan Tomayko - -"""A high-level cross-protocol url-grabber. - -GENERAL ARGUMENTS (kwargs) - - Where possible, the module-level default is indicated, and legal - values are provided. - - copy_local = 0 [0|1] - - ignored except for file:// urls, in which case it specifies - whether urlgrab should still make a copy of the file, or simply - point to the existing copy. The module level default for this - option is 0. - - close_connection = 0 [0|1] - - tells URLGrabber to close the connection after a file has been - transfered. This is ignored unless the download happens with the - http keepalive handler (keepalive=1). Otherwise, the connection - is left open for further use. The module level default for this - option is 0 (keepalive connections will not be closed). - - keepalive = 1 [0|1] - - specifies whether keepalive should be used for HTTP/1.1 servers - that support it. The module level default for this option is 1 - (keepalive is enabled). - - progress_obj = None - - a class instance that supports the following methods: - po.start(filename, url, basename, length, text) - # length will be None if unknown - po.update(read) # read == bytes read so far - po.end() - - text = None - - specifies an alternativ text item in the beginning of the progress - bar line. If not given, the basename of the file is used. - - throttle = 1.0 - - a number - if it's an int, it's the bytes/second throttle limit. - If it's a float, it is first multiplied by bandwidth. If throttle - == 0, throttling is disabled. If None, the module-level default - (which can be set on default_grabber.throttle) is used. See - BANDWIDTH THROTTLING for more information. - - timeout = None - - a positive float expressing the number of seconds to wait for socket - operations. If the value is None or 0.0, socket operations will block - forever. Setting this option causes urlgrabber to call the settimeout - method on the Socket object used for the request. See the Python - documentation on settimeout for more information. - http://www.python.org/doc/current/lib/socket-objects.html - - bandwidth = 0 - - the nominal max bandwidth in bytes/second. If throttle is a float - and bandwidth == 0, throttling is disabled. If None, the - module-level default (which can be set on - default_grabber.bandwidth) is used. See BANDWIDTH THROTTLING for - more information. - - range = None - - a tuple of the form (first_byte, last_byte) describing a byte - range to retrieve. Either or both of the values may set to - None. If first_byte is None, byte offset 0 is assumed. If - last_byte is None, the last byte available is assumed. Note that - the range specification is python-like in that (0,10) will yeild - the first 10 bytes of the file. - - If set to None, no range will be used. - - reget = None [None|'simple'|'check_timestamp'] - - whether to attempt to reget a partially-downloaded file. Reget - only applies to .urlgrab and (obviously) only if there is a - partially downloaded file. Reget has two modes: - - 'simple' -- the local file will always be trusted. If there - are 100 bytes in the local file, then the download will always - begin 100 bytes into the requested file. - - 'check_timestamp' -- the timestamp of the server file will be - compared to the timestamp of the local file. ONLY if the - local file is newer than or the same age as the server file - will reget be used. If the server file is newer, or the - timestamp is not returned, the entire file will be fetched. - - NOTE: urlgrabber can do very little to verify that the partial - file on disk is identical to the beginning of the remote file. - You may want to either employ a custom "checkfunc" or simply avoid - using reget in situations where corruption is a concern. - - user_agent = 'urlgrabber/VERSION' - - a string, usually of the form 'AGENT/VERSION' that is provided to - HTTP servers in the User-agent header. The module level default - for this option is "urlgrabber/VERSION". - - http_headers = None - - a tuple of 2-tuples, each containing a header and value. These - will be used for http and https requests only. For example, you - can do - http_headers = (('Pragma', 'no-cache'),) - - ftp_headers = None - - this is just like http_headers, but will be used for ftp requests. - - proxies = None - - a dictionary that maps protocol schemes to proxy hosts. For - example, to use a proxy server on host "foo" port 3128 for http - and https URLs: - proxies={ 'http' : 'http://foo:3128', 'https' : 'http://foo:3128' } - note that proxy authentication information may be provided using - normal URL constructs: - proxies={ 'http' : 'http://user:host@foo:3128' } - Lastly, if proxies is None, the default environment settings will - be used. - - prefix = None - - a url prefix that will be prepended to all requested urls. For - example: - g = URLGrabber(prefix='http://foo.com/mirror/') - g.urlgrab('some/file.txt') - ## this will fetch 'http://foo.com/mirror/some/file.txt' - This option exists primarily to allow identical behavior to - MirrorGroup (and derived) instances. Note: a '/' will be inserted - if necessary, so you cannot specify a prefix that ends with a - partial file or directory name. - - opener = None - - Overrides the default urllib2.OpenerDirector provided to urllib2 - when making requests. This option exists so that the urllib2 - handler chain may be customized. Note that the range, reget, - proxy, and keepalive features require that custom handlers be - provided to urllib2 in order to function properly. If an opener - option is provided, no attempt is made by urlgrabber to ensure - chain integrity. You are responsible for ensuring that any - extension handlers are present if said features are required. - - data = None - - Only relevant for the HTTP family (and ignored for other - protocols), this allows HTTP POSTs. When the data kwarg is - present (and not None), an HTTP request will automatically become - a POST rather than GET. This is done by direct passthrough to - urllib2. If you use this, you may also want to set the - 'Content-length' and 'Content-type' headers with the http_headers - option. Note that python 2.2 handles the case of these - badly and if you do not use the proper case (shown here), your - values will be overridden with the defaults. - - -RETRY RELATED ARGUMENTS - - retry = None - - the number of times to retry the grab before bailing. If this is - zero, it will retry forever. This was intentional... really, it - was :). If this value is not supplied or is supplied but is None - retrying does not occur. - - retrycodes = [-1,2,4,5,6,7] - - a sequence of errorcodes (values of e.errno) for which it should - retry. See the doc on URLGrabError for more details on this. You - might consider modifying a copy of the default codes rather than - building yours from scratch so that if the list is extended in the - future (or one code is split into two) you can still enjoy the - benefits of the default list. You can do that with something like - this: - - retrycodes = urlgrabber.grabber.URLGrabberOptions().retrycodes - if 12 not in retrycodes: - retrycodes.append(12) - - checkfunc = None - - a function to do additional checks. This defaults to None, which - means no additional checking. The function should simply return - on a successful check. It should raise URLGrabError on an - unsuccessful check. Raising of any other exception will be - considered immediate failure and no retries will occur. - - If it raises URLGrabError, the error code will determine the retry - behavior. Negative error numbers are reserved for use by these - passed in functions, so you can use many negative numbers for - different types of failure. By default, -1 results in a retry, - but this can be customized with retrycodes. - - If you simply pass in a function, it will be given exactly one - argument: a CallbackObject instance with the .url attribute - defined and either .filename (for urlgrab) or .data (for urlread). - For urlgrab, .filename is the name of the local file. For - urlread, .data is the actual string data. If you need other - arguments passed to the callback (program state of some sort), you - can do so like this: - - checkfunc=(function, ('arg1', 2), {'kwarg': 3}) - - if the downloaded file has filename /tmp/stuff, then this will - result in this call (for urlgrab): - - function(obj, 'arg1', 2, kwarg=3) - # obj.filename = '/tmp/stuff' - # obj.url = 'http://foo.com/stuff' - - NOTE: both the "args" tuple and "kwargs" dict must be present if - you use this syntax, but either (or both) can be empty. - - failure_callback = None - - The callback that gets called during retries when an attempt to - fetch a file fails. The syntax for specifying the callback is - identical to checkfunc, except for the attributes defined in the - CallbackObject instance. The attributes for failure_callback are: - - exception = the raised exception - url = the url we're trying to fetch - tries = the number of tries so far (including this one) - retry = the value of the retry option - - The callback is present primarily to inform the calling program of - the failure, but if it raises an exception (including the one it's - passed) that exception will NOT be caught and will therefore cause - future retries to be aborted. - - The callback is called for EVERY failure, including the last one. - On the last try, the callback can raise an alternate exception, - but it cannot (without severe trickiness) prevent the exception - from being raised. - - interrupt_callback = None - - This callback is called if KeyboardInterrupt is received at any - point in the transfer. Basically, this callback can have three - impacts on the fetch process based on the way it exits: - - 1) raise no exception: the current fetch will be aborted, but - any further retries will still take place - - 2) raise a URLGrabError: if you're using a MirrorGroup, then - this will prompt a failover to the next mirror according to - the behavior of the MirrorGroup subclass. It is recommended - that you raise URLGrabError with code 15, 'user abort'. If - you are NOT using a MirrorGroup subclass, then this is the - same as (3). - - 3) raise some other exception (such as KeyboardInterrupt), which - will not be caught at either the grabber or mirror levels. - That is, it will be raised up all the way to the caller. - - This callback is very similar to failure_callback. They are - passed the same arguments, so you could use the same function for - both. - - urlparser = URLParser() - - The URLParser class handles pre-processing of URLs, including - auth-handling for user/pass encoded in http urls, file handing - (that is, filenames not sent as a URL), and URL quoting. If you - want to override any of this behavior, you can pass in a - replacement instance. See also the 'quote' option. - - quote = None - - Whether or not to quote the path portion of a url. - quote = 1 -> quote the URLs (they're not quoted yet) - quote = 0 -> do not quote them (they're already quoted) - quote = None -> guess what to do - - This option only affects proper urls like 'file:///etc/passwd'; it - does not affect 'raw' filenames like '/etc/passwd'. The latter - will always be quoted as they are converted to URLs. Also, only - the path part of a url is quoted. If you need more fine-grained - control, you should probably subclass URLParser and pass it in via - the 'urlparser' option. - -BANDWIDTH THROTTLING - - urlgrabber supports throttling via two values: throttle and - bandwidth Between the two, you can either specify and absolute - throttle threshold or specify a theshold as a fraction of maximum - available bandwidth. - - throttle is a number - if it's an int, it's the bytes/second - throttle limit. If it's a float, it is first multiplied by - bandwidth. If throttle == 0, throttling is disabled. If None, the - module-level default (which can be set with set_throttle) is used. - - bandwidth is the nominal max bandwidth in bytes/second. If throttle - is a float and bandwidth == 0, throttling is disabled. If None, the - module-level default (which can be set with set_bandwidth) is used. - - THROTTLING EXAMPLES: - - Lets say you have a 100 Mbps connection. This is (about) 10^8 bits - per second, or 12,500,000 Bytes per second. You have a number of - throttling options: - - *) set_bandwidth(12500000); set_throttle(0.5) # throttle is a float - - This will limit urlgrab to use half of your available bandwidth. - - *) set_throttle(6250000) # throttle is an int - - This will also limit urlgrab to use half of your available - bandwidth, regardless of what bandwidth is set to. - - *) set_throttle(6250000); set_throttle(1.0) # float - - Use half your bandwidth - - *) set_throttle(6250000); set_throttle(2.0) # float - - Use up to 12,500,000 Bytes per second (your nominal max bandwidth) - - *) set_throttle(6250000); set_throttle(0) # throttle = 0 - - Disable throttling - this is more efficient than a very large - throttle setting. - - *) set_throttle(0); set_throttle(1.0) # throttle is float, bandwidth = 0 - - Disable throttling - this is the default when the module is loaded. - - SUGGESTED AUTHOR IMPLEMENTATION (THROTTLING) - - While this is flexible, it's not extremely obvious to the user. I - suggest you implement a float throttle as a percent to make the - distinction between absolute and relative throttling very explicit. - - Also, you may want to convert the units to something more convenient - than bytes/second, such as kbps or kB/s, etc. - -""" - -# $Id: grabber.py,v 1.48 2006/09/22 00:58:05 mstenner Exp $ - -import os -import os.path -import sys -import urlparse -import rfc822 -import time -import string -import urllib -import urllib2 -from stat import * # S_* and ST_* - -######################################################################## -# MODULE INITIALIZATION -######################################################################## -try: - exec('from ' + (__name__.split('.'))[0] + ' import __version__') -except: - __version__ = '???' - -import sslfactory - -auth_handler = urllib2.HTTPBasicAuthHandler( \ - urllib2.HTTPPasswordMgrWithDefaultRealm()) - -try: - from i18n import _ -except ImportError, msg: - def _(st): return st - -try: - from httplib import HTTPException -except ImportError, msg: - HTTPException = None - -try: - # This is a convenient way to make keepalive optional. - # Just rename the module so it can't be imported. - import keepalive - from keepalive import HTTPHandler, HTTPSHandler - have_keepalive = True -except ImportError, msg: - have_keepalive = False - -try: - # add in range support conditionally too - import byterange - from byterange import HTTPRangeHandler, HTTPSRangeHandler, \ - FileRangeHandler, FTPRangeHandler, range_tuple_normalize, \ - range_tuple_to_header, RangeError -except ImportError, msg: - range_handlers = () - RangeError = None - have_range = 0 -else: - range_handlers = (HTTPRangeHandler(), HTTPSRangeHandler(), - FileRangeHandler(), FTPRangeHandler()) - have_range = 1 - - -# check whether socket timeout support is available (Python >= 2.3) -import socket -try: - TimeoutError = socket.timeout - have_socket_timeout = True -except AttributeError: - TimeoutError = None - have_socket_timeout = False - -######################################################################## -# functions for debugging output. These functions are here because they -# are also part of the module initialization. -DEBUG = None -def set_logger(DBOBJ): - """Set the DEBUG object. This is called by _init_default_logger when - the environment variable URLGRABBER_DEBUG is set, but can also be - called by a calling program. Basically, if the calling program uses - the logging module and would like to incorporate urlgrabber logging, - then it can do so this way. It's probably not necessary as most - internal logging is only for debugging purposes. - - The passed-in object should be a logging.Logger instance. It will - be pushed into the keepalive and byterange modules if they're - being used. The mirror module pulls this object in on import, so - you will need to manually push into it. In fact, you may find it - tidier to simply push your logging object (or objects) into each - of these modules independently. - """ - - global DEBUG - DEBUG = DBOBJ - if have_keepalive and keepalive.DEBUG is None: - keepalive.DEBUG = DBOBJ - if have_range and byterange.DEBUG is None: - byterange.DEBUG = DBOBJ - if sslfactory.DEBUG is None: - sslfactory.DEBUG = DBOBJ - -def _init_default_logger(): - '''Examines the environment variable URLGRABBER_DEBUG and creates - a logging object (logging.logger) based on the contents. It takes - the form - - URLGRABBER_DEBUG=level,filename - - where "level" can be either an integer or a log level from the - logging module (DEBUG, INFO, etc). If the integer is zero or - less, logging will be disabled. Filename is the filename where - logs will be sent. If it is "-", then stdout will be used. If - the filename is empty or missing, stderr will be used. If the - variable cannot be processed or the logging module cannot be - imported (python < 2.3) then logging will be disabled. Here are - some examples: - - URLGRABBER_DEBUG=1,debug.txt # log everything to debug.txt - URLGRABBER_DEBUG=WARNING,- # log warning and higher to stdout - URLGRABBER_DEBUG=INFO # log info and higher to stderr - - This funtion is called during module initialization. It is not - intended to be called from outside. The only reason it is a - function at all is to keep the module-level namespace tidy and to - collect the code into a nice block.''' - - try: - dbinfo = os.environ['URLGRABBER_DEBUG'].split(',') - import logging - level = logging._levelNames.get(dbinfo[0], int(dbinfo[0])) - if level < 1: raise ValueError() - - formatter = logging.Formatter('%(asctime)s %(message)s') - if len(dbinfo) > 1: filename = dbinfo[1] - else: filename = '' - if filename == '': handler = logging.StreamHandler(sys.stderr) - elif filename == '-': handler = logging.StreamHandler(sys.stdout) - else: handler = logging.FileHandler(filename) - handler.setFormatter(formatter) - DBOBJ = logging.getLogger('urlgrabber') - DBOBJ.addHandler(handler) - DBOBJ.setLevel(level) - except (KeyError, ImportError, ValueError): - DBOBJ = None - set_logger(DBOBJ) - -_init_default_logger() -######################################################################## -# END MODULE INITIALIZATION -######################################################################## - - - -class URLGrabError(IOError): - """ - URLGrabError error codes: - - URLGrabber error codes (0 -- 255) - 0 - everything looks good (you should never see this) - 1 - malformed url - 2 - local file doesn't exist - 3 - request for non-file local file (dir, etc) - 4 - IOError on fetch - 5 - OSError on fetch - 6 - no content length header when we expected one - 7 - HTTPException - 8 - Exceeded read limit (for urlread) - 9 - Requested byte range not satisfiable. - 10 - Byte range requested, but range support unavailable - 11 - Illegal reget mode - 12 - Socket timeout - 13 - malformed proxy url - 14 - HTTPError (includes .code and .exception attributes) - 15 - user abort - - MirrorGroup error codes (256 -- 511) - 256 - No more mirrors left to try - - Custom (non-builtin) classes derived from MirrorGroup (512 -- 767) - [ this range reserved for application-specific error codes ] - - Retry codes (< 0) - -1 - retry the download, unknown reason - - Note: to test which group a code is in, you can simply do integer - division by 256: e.errno / 256 - - Negative codes are reserved for use by functions passed in to - retrygrab with checkfunc. The value -1 is built in as a generic - retry code and is already included in the retrycodes list. - Therefore, you can create a custom check function that simply - returns -1 and the fetch will be re-tried. For more customized - retries, you can use other negative number and include them in - retry-codes. This is nice for outputting useful messages about - what failed. - - You can use these error codes like so: - try: urlgrab(url) - except URLGrabError, e: - if e.errno == 3: ... - # or - print e.strerror - # or simply - print e #### print '[Errno %i] %s' % (e.errno, e.strerror) - """ - pass - -class CallbackObject: - """Container for returned callback data. - - This is currently a dummy class into which urlgrabber can stuff - information for passing to callbacks. This way, the prototype for - all callbacks is the same, regardless of the data that will be - passed back. Any function that accepts a callback function as an - argument SHOULD document what it will define in this object. - - It is possible that this class will have some greater - functionality in the future. - """ - def __init__(self, **kwargs): - self.__dict__.update(kwargs) - -def urlgrab(url, filename=None, **kwargs): - """grab the file at <url> and make a local copy at <filename> - If filename is none, the basename of the url is used. - urlgrab returns the filename of the local file, which may be different - from the passed-in filename if the copy_local kwarg == 0. - - See module documentation for a description of possible kwargs. - """ - return default_grabber.urlgrab(url, filename, **kwargs) - -def urlopen(url, **kwargs): - """open the url and return a file object - If a progress object or throttle specifications exist, then - a special file object will be returned that supports them. - The file object can be treated like any other file object. - - See module documentation for a description of possible kwargs. - """ - return default_grabber.urlopen(url, **kwargs) - -def urlread(url, limit=None, **kwargs): - """read the url into a string, up to 'limit' bytes - If the limit is exceeded, an exception will be thrown. Note that urlread - is NOT intended to be used as a way of saying "I want the first N bytes" - but rather 'read the whole file into memory, but don't use too much' - - See module documentation for a description of possible kwargs. - """ - return default_grabber.urlread(url, limit, **kwargs) - - -class URLParser: - """Process the URLs before passing them to urllib2. - - This class does several things: - - * add any prefix - * translate a "raw" file to a proper file: url - * handle any http or https auth that's encoded within the url - * quote the url - - Only the "parse" method is called directly, and it calls sub-methods. - - An instance of this class is held in the options object, which - means that it's easy to change the behavior by sub-classing and - passing the replacement in. It need only have a method like: - - url, parts = urlparser.parse(url, opts) - """ - - def parse(self, url, opts): - """parse the url and return the (modified) url and its parts - - Note: a raw file WILL be quoted when it's converted to a URL. - However, other urls (ones which come with a proper scheme) may - or may not be quoted according to opts.quote - - opts.quote = 1 --> quote it - opts.quote = 0 --> do not quote it - opts.quote = None --> guess - """ - quote = opts.quote - - if opts.prefix: - url = self.add_prefix(url, opts.prefix) - - parts = urlparse.urlparse(url) - (scheme, host, path, parm, query, frag) = parts - - if not scheme or (len(scheme) == 1 and scheme in string.letters): - # if a scheme isn't specified, we guess that it's "file:" - if url[0] not in '/\\': url = os.path.abspath(url) - url = 'file:' + urllib.pathname2url(url) - parts = urlparse.urlparse(url) - quote = 0 # pathname2url quotes, so we won't do it again - - if scheme in ['http', 'https']: - parts = self.process_http(parts) - - if quote is None: - quote = self.guess_should_quote(parts) - if quote: - parts = self.quote(parts) - - url = urlparse.urlunparse(parts) - return url, parts - - def add_prefix(self, url, prefix): - if prefix[-1] == '/' or url[0] == '/': - url = prefix + url - else: - url = prefix + '/' + url - return url - - def process_http(self, parts): - (scheme, host, path, parm, query, frag) = parts - - if '@' in host and auth_handler: - try: - user_pass, host = host.split('@', 1) - if ':' in user_pass: - user, password = user_pass.split(':', 1) - except ValueError, e: - raise URLGrabError(1, _('Bad URL: %s') % url) - if DEBUG: DEBUG.info('adding HTTP auth: %s, XXXXXXXX', user) - auth_handler.add_password(None, host, user, password) - - return (scheme, host, path, parm, query, frag) - - def quote(self, parts): - """quote the URL - - This method quotes ONLY the path part. If you need to quote - other parts, you should override this and pass in your derived - class. The other alternative is to quote other parts before - passing into urlgrabber. - """ - (scheme, host, path, parm, query, frag) = parts - path = urllib.quote(path) - return (scheme, host, path, parm, query, frag) - - hexvals = '0123456789ABCDEF' - def guess_should_quote(self, parts): - """ - Guess whether we should quote a path. This amounts to - guessing whether it's already quoted. - - find ' ' -> 1 - find '%' -> 1 - find '%XX' -> 0 - else -> 1 - """ - (scheme, host, path, parm, query, frag) = parts - if ' ' in path: - return 1 - ind = string.find(path, '%') - if ind > -1: - while ind > -1: - if len(path) < ind+3: - return 1 - code = path[ind+1:ind+3].upper() - if code[0] not in self.hexvals or \ - code[1] not in self.hexvals: - return 1 - ind = string.find(path, '%', ind+1) - return 0 - return 1 - -class URLGrabberOptions: - """Class to ease kwargs handling.""" - - def __init__(self, delegate=None, **kwargs): - """Initialize URLGrabberOptions object. - Set default values for all options and then update options specified - in kwargs. - """ - self.delegate = delegate - if delegate is None: - self._set_defaults() - self._set_attributes(**kwargs) - - def __getattr__(self, name): - if self.delegate and hasattr(self.delegate, name): - return getattr(self.delegate, name) - raise AttributeError, name - - def raw_throttle(self): - """Calculate raw throttle value from throttle and bandwidth - values. - """ - if self.throttle <= 0: - return 0 - elif type(self.throttle) == type(0): - return float(self.throttle) - else: # throttle is a float - return self.bandwidth * self.throttle - - def derive(self, **kwargs): - """Create a derived URLGrabberOptions instance. - This method creates a new instance and overrides the - options specified in kwargs. - """ - return URLGrabberOptions(delegate=self, **kwargs) - - def _set_attributes(self, **kwargs): - """Update object attributes with those provided in kwargs.""" - self.__dict__.update(kwargs) - if have_range and kwargs.has_key('range'): - # normalize the supplied range value - self.range = range_tuple_normalize(self.range) - if not self.reget in [None, 'simple', 'check_timestamp']: - raise URLGrabError(11, _('Illegal reget mode: %s') \ - % (self.reget, )) - - def _set_defaults(self): - """Set all options to their default values. - When adding new options, make sure a default is - provided here. - """ - self.progress_obj = None - self.throttle = 1.0 - self.bandwidth = 0 - self.retry = None - self.retrycodes = [-1,2,4,5,6,7] - self.checkfunc = None - self.copy_local = 0 - self.close_connection = 0 - self.range = None - self.user_agent = 'urlgrabber/%s' % __version__ - self.keepalive = 1 - self.proxies = None - self.reget = None - self.failure_callback = None - self.interrupt_callback = None - self.prefix = None - self.opener = None - self.cache_openers = True - self.timeout = None - self.text = None - self.http_headers = None - self.ftp_headers = None - self.data = None - self.urlparser = URLParser() - self.quote = None - self.ssl_ca_cert = None - self.ssl_context = None - -class URLGrabber: - """Provides easy opening of URLs with a variety of options. - - All options are specified as kwargs. Options may be specified when - the class is created and may be overridden on a per request basis. - - New objects inherit default values from default_grabber. - """ - - def __init__(self, **kwargs): - self.opts = URLGrabberOptions(**kwargs) - - def _retry(self, opts, func, *args): - tries = 0 - while 1: - # there are only two ways out of this loop. The second has - # several "sub-ways" - # 1) via the return in the "try" block - # 2) by some exception being raised - # a) an excepton is raised that we don't "except" - # b) a callback raises ANY exception - # c) we're not retry-ing or have run out of retries - # d) the URLGrabError code is not in retrycodes - # beware of infinite loops :) - tries = tries + 1 - exception = None - retrycode = None - callback = None - if DEBUG: DEBUG.info('attempt %i/%s: %s', - tries, opts.retry, args[0]) - try: - r = apply(func, (opts,) + args, {}) - if DEBUG: DEBUG.info('success') - return r - except URLGrabError, e: - exception = e - callback = opts.failure_callback - retrycode = e.errno - except KeyboardInterrupt, e: - exception = e - callback = opts.interrupt_callback - - if DEBUG: DEBUG.info('exception: %s', exception) - if callback: - if DEBUG: DEBUG.info('calling callback: %s', callback) - cb_func, cb_args, cb_kwargs = self._make_callback(callback) - obj = CallbackObject(exception=exception, url=args[0], - tries=tries, retry=opts.retry) - cb_func(obj, *cb_args, **cb_kwargs) - - if (opts.retry is None) or (tries == opts.retry): - if DEBUG: DEBUG.info('retries exceeded, re-raising') - raise - - if (retrycode is not None) and (retrycode not in opts.retrycodes): - if DEBUG: DEBUG.info('retrycode (%i) not in list %s, re-raising', - retrycode, opts.retrycodes) - raise - - def urlopen(self, url, **kwargs): - """open the url and return a file object - If a progress object or throttle value specified when this - object was created, then a special file object will be - returned that supports them. The file object can be treated - like any other file object. - """ - opts = self.opts.derive(**kwargs) - (url,parts) = opts.urlparser.parse(url, opts) - def retryfunc(opts, url): - return URLGrabberFileObject(url, filename=None, opts=opts) - return self._retry(opts, retryfunc, url) - - def urlgrab(self, url, filename=None, **kwargs): - """grab the file at <url> and make a local copy at <filename> - If filename is none, the basename of the url is used. - urlgrab returns the filename of the local file, which may be - different from the passed-in filename if copy_local == 0. - """ - opts = self.opts.derive(**kwargs) - (url,parts) = opts.urlparser.parse(url, opts) - (scheme, host, path, parm, query, frag) = parts - if filename is None: - filename = os.path.basename( urllib.unquote(path) ) - if scheme == 'file' and not opts.copy_local: - # just return the name of the local file - don't make a - # copy currently - path = urllib.url2pathname(path) - if host: - path = os.path.normpath('//' + host + path) - if not os.path.exists(path): - raise URLGrabError(2, - _('Local file does not exist: %s') % (path, )) - elif not os.path.isfile(path): - raise URLGrabError(3, - _('Not a normal file: %s') % (path, )) - elif not opts.range: - return path - - def retryfunc(opts, url, filename): - fo = URLGrabberFileObject(url, filename, opts) - try: - fo._do_grab() - if not opts.checkfunc is None: - cb_func, cb_args, cb_kwargs = \ - self._make_callback(opts.checkfunc) - obj = CallbackObject() - obj.filename = filename - obj.url = url - apply(cb_func, (obj, )+cb_args, cb_kwargs) - finally: - fo.close() - return filename - - return self._retry(opts, retryfunc, url, filename) - - def urlread(self, url, limit=None, **kwargs): - """read the url into a string, up to 'limit' bytes - If the limit is exceeded, an exception will be thrown. Note - that urlread is NOT intended to be used as a way of saying - "I want the first N bytes" but rather 'read the whole file - into memory, but don't use too much' - """ - opts = self.opts.derive(**kwargs) - (url,parts) = opts.urlparser.parse(url, opts) - if limit is not None: - limit = limit + 1 - - def retryfunc(opts, url, limit): - fo = URLGrabberFileObject(url, filename=None, opts=opts) - s = '' - try: - # this is an unfortunate thing. Some file-like objects - # have a default "limit" of None, while the built-in (real) - # file objects have -1. They each break the other, so for - # now, we just force the default if necessary. - if limit is None: s = fo.read() - else: s = fo.read(limit) - - if not opts.checkfunc is None: - cb_func, cb_args, cb_kwargs = \ - self._make_callback(opts.checkfunc) - obj = CallbackObject() - obj.data = s - obj.url = url - apply(cb_func, (obj, )+cb_args, cb_kwargs) - finally: - fo.close() - return s - - s = self._retry(opts, retryfunc, url, limit) - if limit and len(s) > limit: - raise URLGrabError(8, - _('Exceeded limit (%i): %s') % (limit, url)) - return s - - def _make_callback(self, callback_obj): - if callable(callback_obj): - return callback_obj, (), {} - else: - return callback_obj - -# create the default URLGrabber used by urlXXX functions. -# NOTE: actual defaults are set in URLGrabberOptions -default_grabber = URLGrabber() - -class URLGrabberFileObject: - """This is a file-object wrapper that supports progress objects - and throttling. - - This exists to solve the following problem: lets say you want to - drop-in replace a normal open with urlopen. You want to use a - progress meter and/or throttling, but how do you do that without - rewriting your code? Answer: urlopen will return a wrapped file - object that does the progress meter and-or throttling internally. - """ - - def __init__(self, url, filename, opts): - self.url = url - self.filename = filename - self.opts = opts - self.fo = None - self._rbuf = '' - self._rbufsize = 1024*8 - self._ttime = time.time() - self._tsize = 0 - self._amount_read = 0 - self._opener = None - self._do_open() - - def __getattr__(self, name): - """This effectively allows us to wrap at the instance level. - Any attribute not found in _this_ object will be searched for - in self.fo. This includes methods.""" - if hasattr(self.fo, name): - return getattr(self.fo, name) - raise AttributeError, name - - def _get_opener(self): - """Build a urllib2 OpenerDirector based on request options.""" - if self.opts.opener: - return self.opts.opener - elif self._opener is None: - handlers = [] - need_keepalive_handler = (have_keepalive and self.opts.keepalive) - need_range_handler = (range_handlers and \ - (self.opts.range or self.opts.reget)) - # if you specify a ProxyHandler when creating the opener - # it _must_ come before all other handlers in the list or urllib2 - # chokes. - if self.opts.proxies: - handlers.append( CachedProxyHandler(self.opts.proxies) ) - - # ------------------------------------------------------- - # OK, these next few lines are a serious kludge to get - # around what I think is a bug in python 2.2's - # urllib2. The basic idea is that default handlers - # get applied first. If you override one (like a - # proxy handler), then the default gets pulled, but - # the replacement goes on the end. In the case of - # proxies, this means the normal handler picks it up - # first and the proxy isn't used. Now, this probably - # only happened with ftp or non-keepalive http, so not - # many folks saw it. The simple approach to fixing it - # is just to make sure you override the other - # conflicting defaults as well. I would LOVE to see - # these go way or be dealt with more elegantly. The - # problem isn't there after 2.2. -MDS 2005/02/24 - if not need_keepalive_handler: - handlers.append( urllib2.HTTPHandler() ) - if not need_range_handler: - handlers.append( urllib2.FTPHandler() ) - # ------------------------------------------------------- - - ssl_factory = sslfactory.get_factory(self.opts.ssl_ca_cert, - self.opts.ssl_context) - - if need_keepalive_handler: - handlers.append(HTTPHandler()) - handlers.append(HTTPSHandler(ssl_factory)) - if need_range_handler: - handlers.extend( range_handlers ) - handlers.append( auth_handler ) - if self.opts.cache_openers: - self._opener = CachedOpenerDirector(ssl_factory, *handlers) - else: - self._opener = ssl_factory.create_opener(*handlers) - # OK, I don't like to do this, but otherwise, we end up with - # TWO user-agent headers. - self._opener.addheaders = [] - return self._opener - - def _do_open(self): - opener = self._get_opener() - - req = urllib2.Request(self.url, self.opts.data) # build request object - self._add_headers(req) # add misc headers that we need - self._build_range(req) # take care of reget and byterange stuff - - fo, hdr = self._make_request(req, opener) - if self.reget_time and self.opts.reget == 'check_timestamp': - # do this if we have a local file with known timestamp AND - # we're in check_timestamp reget mode. - fetch_again = 0 - try: - modified_tuple = hdr.getdate_tz('last-modified') - modified_stamp = rfc822.mktime_tz(modified_tuple) - if modified_stamp > self.reget_time: fetch_again = 1 - except (TypeError,): - fetch_again = 1 - - if fetch_again: - # the server version is newer than the (incomplete) local - # version, so we should abandon the version we're getting - # and fetch the whole thing again. - fo.close() - self.opts.reget = None - del req.headers['Range'] - self._build_range(req) - fo, hdr = self._make_request(req, opener) - - (scheme, host, path, parm, query, frag) = urlparse.urlparse(self.url) - path = urllib.unquote(path) - if not (self.opts.progress_obj or self.opts.raw_throttle() \ - or self.opts.timeout): - # if we're not using the progress_obj, throttling, or timeout - # we can get a performance boost by going directly to - # the underlying fileobject for reads. - self.read = fo.read - if hasattr(fo, 'readline'): - self.readline = fo.readline - elif self.opts.progress_obj: - try: - length = int(hdr['Content-Length']) - length = length + self._amount_read # Account for regets - except (KeyError, ValueError, TypeError): - length = None - - self.opts.progress_obj.start(str(self.filename), - urllib.unquote(self.url), - os.path.basename(path), - length, text=self.opts.text) - self.opts.progress_obj.update(0) - (self.fo, self.hdr) = (fo, hdr) - - def _add_headers(self, req): - if self.opts.user_agent: - req.add_header('User-agent', self.opts.user_agent) - try: req_type = req.get_type() - except ValueError: req_type = None - if self.opts.http_headers and req_type in ('http', 'https'): - for h, v in self.opts.http_headers: - req.add_header(h, v) - if self.opts.ftp_headers and req_type == 'ftp': - for h, v in self.opts.ftp_headers: - req.add_header(h, v) - - def _build_range(self, req): - self.reget_time = None - self.append = 0 - reget_length = 0 - rt = None - if have_range and self.opts.reget and type(self.filename) == type(''): - # we have reget turned on and we're dumping to a file - try: - s = os.stat(self.filename) - except OSError: - pass - else: - self.reget_time = s[ST_MTIME] - reget_length = s[ST_SIZE] - - # Set initial length when regetting - self._amount_read = reget_length - - rt = reget_length, '' - self.append = 1 - - if self.opts.range: - if not have_range: - raise URLGrabError(10, _('Byte range requested but range '\ - 'support unavailable')) - rt = self.opts.range - if rt[0]: rt = (rt[0] + reget_length, rt[1]) - - if rt: - header = range_tuple_to_header(rt) - if header: req.add_header('Range', header) - - def _make_request(self, req, opener): - try: - if have_socket_timeout and self.opts.timeout: - old_to = socket.getdefaulttimeout() - socket.setdefaulttimeout(self.opts.timeout) - try: - fo = opener.open(req) - finally: - socket.setdefaulttimeout(old_to) - else: - fo = opener.open(req) - hdr = fo.info() - except ValueError, e: - raise URLGrabError(1, _('Bad URL: %s') % (e, )) - except RangeError, e: - raise URLGrabError(9, str(e)) - except urllib2.HTTPError, e: - new_e = URLGrabError(14, str(e)) - new_e.code = e.code - new_e.exception = e - raise new_e - except IOError, e: - if hasattr(e, 'reason') and have_socket_timeout and \ - isinstance(e.reason, TimeoutError): - raise URLGrabError(12, _('Timeout: %s') % (e, )) - else: - raise URLGrabError(4, _('IOError: %s') % (e, )) - except OSError, e: - raise URLGrabError(5, _('OSError: %s') % (e, )) - except HTTPException, e: - raise URLGrabError(7, _('HTTP Exception (%s): %s') % \ - (e.__class__.__name__, e)) - else: - return (fo, hdr) - - def _do_grab(self): - """dump the file to self.filename.""" - if self.append: new_fo = open(self.filename, 'ab') - else: new_fo = open(self.filename, 'wb') - bs = 1024*8 - size = 0 - - block = self.read(bs) - size = size + len(block) - while block: - new_fo.write(block) - block = self.read(bs) - size = size + len(block) - - new_fo.close() - try: - modified_tuple = self.hdr.getdate_tz('last-modified') - modified_stamp = rfc822.mktime_tz(modified_tuple) - os.utime(self.filename, (modified_stamp, modified_stamp)) - except (TypeError,), e: pass - - return size - - def _fill_buffer(self, amt=None): - """fill the buffer to contain at least 'amt' bytes by reading - from the underlying file object. If amt is None, then it will - read until it gets nothing more. It updates the progress meter - and throttles after every self._rbufsize bytes.""" - # the _rbuf test is only in this first 'if' for speed. It's not - # logically necessary - if self._rbuf and not amt is None: - L = len(self._rbuf) - if amt > L: - amt = amt - L - else: - return - - # if we've made it here, then we don't have enough in the buffer - # and we need to read more. - - buf = [self._rbuf] - bufsize = len(self._rbuf) - while amt is None or amt: - # first, delay if necessary for throttling reasons - if self.opts.raw_throttle(): - diff = self._tsize/self.opts.raw_throttle() - \ - (time.time() - self._ttime) - if diff > 0: time.sleep(diff) - self._ttime = time.time() - - # now read some data, up to self._rbufsize - if amt is None: readamount = self._rbufsize - else: readamount = min(amt, self._rbufsize) - try: - new = self.fo.read(readamount) - except socket.error, e: - raise URLGrabError(4, _('Socket Error: %s') % (e, )) - except TimeoutError, e: - raise URLGrabError(12, _('Timeout: %s') % (e, )) - except IOError, e: - raise URLGrabError(4, _('IOError: %s') %(e,)) - newsize = len(new) - if not newsize: break # no more to read - - if amt: amt = amt - newsize - buf.append(new) - bufsize = bufsize + newsize - self._tsize = newsize - self._amount_read = self._amount_read + newsize - if self.opts.progress_obj: - self.opts.progress_obj.update(self._amount_read) - - self._rbuf = string.join(buf, '') - return - - def read(self, amt=None): - self._fill_buffer(amt) - if amt is None: - s, self._rbuf = self._rbuf, '' - else: - s, self._rbuf = self._rbuf[:amt], self._rbuf[amt:] - return s - - def readline(self, limit=-1): - i = string.find(self._rbuf, '\n') - while i < 0 and not (0 < limit <= len(self._rbuf)): - L = len(self._rbuf) - self._fill_buffer(L + self._rbufsize) - if not len(self._rbuf) > L: break - i = string.find(self._rbuf, '\n', L) - - if i < 0: i = len(self._rbuf) - else: i = i+1 - if 0 <= limit < len(self._rbuf): i = limit - - s, self._rbuf = self._rbuf[:i], self._rbuf[i:] - return s - - def close(self): - if self.opts.progress_obj: - self.opts.progress_obj.end(self._amount_read) - self.fo.close() - if self.opts.close_connection: - try: self.fo.close_connection() - except: pass - -_handler_cache = [] -def CachedOpenerDirector(ssl_factory = None, *handlers): - for (cached_handlers, opener) in _handler_cache: - if cached_handlers == handlers: - for handler in opener.handlers: - handler.add_parent(opener) - return opener - if not ssl_factory: - ssl_factory = sslfactory.get_factory() - opener = ssl_factory.create_opener(*handlers) - _handler_cache.append( (handlers, opener) ) - return opener - -_proxy_cache = [] -def CachedProxyHandler(proxies): - for (pdict, handler) in _proxy_cache: - if pdict == proxies: - if DEBUG: DEBUG.debug('re-using proxy settings: %s', proxies) - break - else: - for k, v in proxies.items(): - utype, url = urllib.splittype(v) - host, other = urllib.splithost(url) - if (utype is None) or (host is None): - raise URLGrabError(13, _('Bad proxy URL: %s') % v) - - if DEBUG: DEBUG.info('creating new proxy handler: %s', proxies) - handler = urllib2.ProxyHandler(proxies) - _proxy_cache.append( (proxies, handler) ) - return handler - -##################################################################### -# DEPRECATED FUNCTIONS -def set_throttle(new_throttle): - """Deprecated. Use: default_grabber.throttle = new_throttle""" - default_grabber.throttle = new_throttle - -def set_bandwidth(new_bandwidth): - """Deprecated. Use: default_grabber.bandwidth = new_bandwidth""" - default_grabber.bandwidth = new_bandwidth - -def set_progress_obj(new_progress_obj): - """Deprecated. Use: default_grabber.progress_obj = new_progress_obj""" - default_grabber.progress_obj = new_progress_obj - -def set_user_agent(new_user_agent): - """Deprecated. Use: default_grabber.user_agent = new_user_agent""" - default_grabber.user_agent = new_user_agent - -def retrygrab(url, filename=None, copy_local=0, close_connection=0, - progress_obj=None, throttle=None, bandwidth=None, - numtries=3, retrycodes=[-1,2,4,5,6,7], checkfunc=None): - """Deprecated. Use: urlgrab() with the retry arg instead""" - kwargs = {'copy_local' : copy_local, - 'close_connection' : close_connection, - 'progress_obj' : progress_obj, - 'throttle' : throttle, - 'bandwidth' : bandwidth, - 'retry' : numtries, - 'retrycodes' : retrycodes, - 'checkfunc' : checkfunc - } - return urlgrab(url, filename, **kwargs) - - -##################################################################### -# TESTING -def _main_test(): - import sys - try: url, filename = sys.argv[1:3] - except ValueError: - print 'usage:', sys.argv[0], \ - '<url> <filename> [copy_local=0|1] [close_connection=0|1]' - sys.exit() - - kwargs = {} - for a in sys.argv[3:]: - k, v = string.split(a, '=', 1) - kwargs[k] = int(v) - - set_throttle(1.0) - set_bandwidth(32 * 1024) - print "throttle: %s, throttle bandwidth: %s B/s" % (default_grabber.throttle, - default_grabber.bandwidth) - - try: from progress import text_progress_meter - except ImportError, e: pass - else: kwargs['progress_obj'] = text_progress_meter() - - try: name = apply(urlgrab, (url, filename), kwargs) - except URLGrabError, e: print e - else: print 'LOCAL FILE:', name - - -def _retry_test(): - import sys - try: url, filename = sys.argv[1:3] - except ValueError: - print 'usage:', sys.argv[0], \ - '<url> <filename> [copy_local=0|1] [close_connection=0|1]' - sys.exit() - - kwargs = {} - for a in sys.argv[3:]: - k, v = string.split(a, '=', 1) - kwargs[k] = int(v) - - try: from progress import text_progress_meter - except ImportError, e: pass - else: kwargs['progress_obj'] = text_progress_meter() - - def cfunc(filename, hello, there='foo'): - print hello, there - import random - rnum = random.random() - if rnum < .5: - print 'forcing retry' - raise URLGrabError(-1, 'forcing retry') - if rnum < .75: - print 'forcing failure' - raise URLGrabError(-2, 'forcing immediate failure') - print 'success' - return - - kwargs['checkfunc'] = (cfunc, ('hello',), {'there':'there'}) - try: name = apply(retrygrab, (url, filename), kwargs) - except URLGrabError, e: print e - else: print 'LOCAL FILE:', name - -def _file_object_test(filename=None): - import random, cStringIO, sys - if filename is None: - filename = __file__ - print 'using file "%s" for comparisons' % filename - fo = open(filename) - s_input = fo.read() - fo.close() - - for testfunc in [_test_file_object_smallread, - _test_file_object_readall, - _test_file_object_readline, - _test_file_object_readlines]: - fo_input = cStringIO.StringIO(s_input) - fo_output = cStringIO.StringIO() - wrapper = URLGrabberFileObject(fo_input, None, 0) - print 'testing %-30s ' % testfunc.__name__, - testfunc(wrapper, fo_output) - s_output = fo_output.getvalue() - if s_output == s_input: print 'passed' - else: print 'FAILED' - -def _test_file_object_smallread(wrapper, fo_output): - while 1: - s = wrapper.read(23) - fo_output.write(s) - if not s: return - -def _test_file_object_readall(wrapper, fo_output): - s = wrapper.read() - fo_output.write(s) - -def _test_file_object_readline(wrapper, fo_output): - while 1: - s = wrapper.readline() - fo_output.write(s) - if not s: return - -def _test_file_object_readlines(wrapper, fo_output): - li = wrapper.readlines() - fo_output.write(string.join(li, '')) - -if __name__ == '__main__': - _main_test() - _retry_test() - _file_object_test('test') diff --git a/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/keepalive.py b/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/keepalive.py deleted file mode 100644 index 71393e2b8d..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/keepalive.py +++ /dev/null @@ -1,617 +0,0 @@ -# This library is free software; you can redistribute it and/or -# modify it under the terms of the GNU Lesser General Public -# License as published by the Free Software Foundation; either -# version 2.1 of the License, or (at your option) any later version. -# -# This library is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Lesser General Public License for more details. -# -# You should have received a copy of the GNU Lesser General Public -# License along with this library; if not, write to the -# Free Software Foundation, Inc., -# 59 Temple Place, Suite 330, -# Boston, MA 02111-1307 USA - -# This file is part of urlgrabber, a high-level cross-protocol url-grabber -# Copyright 2002-2004 Michael D. Stenner, Ryan Tomayko - -"""An HTTP handler for urllib2 that supports HTTP 1.1 and keepalive. - ->>> import urllib2 ->>> from keepalive import HTTPHandler ->>> keepalive_handler = HTTPHandler() ->>> opener = urllib2.build_opener(keepalive_handler) ->>> urllib2.install_opener(opener) ->>> ->>> fo = urllib2.urlopen('http://www.python.org') - -If a connection to a given host is requested, and all of the existing -connections are still in use, another connection will be opened. If -the handler tries to use an existing connection but it fails in some -way, it will be closed and removed from the pool. - -To remove the handler, simply re-run build_opener with no arguments, and -install that opener. - -You can explicitly close connections by using the close_connection() -method of the returned file-like object (described below) or you can -use the handler methods: - - close_connection(host) - close_all() - open_connections() - -NOTE: using the close_connection and close_all methods of the handler -should be done with care when using multiple threads. - * there is nothing that prevents another thread from creating new - connections immediately after connections are closed - * no checks are done to prevent in-use connections from being closed - ->>> keepalive_handler.close_all() - -EXTRA ATTRIBUTES AND METHODS - - Upon a status of 200, the object returned has a few additional - attributes and methods, which should not be used if you want to - remain consistent with the normal urllib2-returned objects: - - close_connection() - close the connection to the host - readlines() - you know, readlines() - status - the return status (ie 404) - reason - english translation of status (ie 'File not found') - - If you want the best of both worlds, use this inside an - AttributeError-catching try: - - >>> try: status = fo.status - >>> except AttributeError: status = None - - Unfortunately, these are ONLY there if status == 200, so it's not - easy to distinguish between non-200 responses. The reason is that - urllib2 tries to do clever things with error codes 301, 302, 401, - and 407, and it wraps the object upon return. - - For python versions earlier than 2.4, you can avoid this fancy error - handling by setting the module-level global HANDLE_ERRORS to zero. - You see, prior to 2.4, it's the HTTP Handler's job to determine what - to handle specially, and what to just pass up. HANDLE_ERRORS == 0 - means "pass everything up". In python 2.4, however, this job no - longer belongs to the HTTP Handler and is now done by a NEW handler, - HTTPErrorProcessor. Here's the bottom line: - - python version < 2.4 - HANDLE_ERRORS == 1 (default) pass up 200, treat the rest as - errors - HANDLE_ERRORS == 0 pass everything up, error processing is - left to the calling code - python version >= 2.4 - HANDLE_ERRORS == 1 pass up 200, treat the rest as errors - HANDLE_ERRORS == 0 (default) pass everything up, let the - other handlers (specifically, - HTTPErrorProcessor) decide what to do - - In practice, setting the variable either way makes little difference - in python 2.4, so for the most consistent behavior across versions, - you probably just want to use the defaults, which will give you - exceptions on errors. - -""" - -# $Id: keepalive.py,v 1.16 2006/09/22 00:58:05 mstenner Exp $ - -import urllib2 -import httplib -import socket -import thread - -DEBUG = None - -import sslfactory - -import sys -if sys.version_info < (2, 4): HANDLE_ERRORS = 1 -else: HANDLE_ERRORS = 0 - -class ConnectionManager: - """ - The connection manager must be able to: - * keep track of all existing - """ - def __init__(self): - self._lock = thread.allocate_lock() - self._hostmap = {} # map hosts to a list of connections - self._connmap = {} # map connections to host - self._readymap = {} # map connection to ready state - - def add(self, host, connection, ready): - self._lock.acquire() - try: - if not self._hostmap.has_key(host): self._hostmap[host] = [] - self._hostmap[host].append(connection) - self._connmap[connection] = host - self._readymap[connection] = ready - finally: - self._lock.release() - - def remove(self, connection): - self._lock.acquire() - try: - try: - host = self._connmap[connection] - except KeyError: - pass - else: - del self._connmap[connection] - del self._readymap[connection] - self._hostmap[host].remove(connection) - if not self._hostmap[host]: del self._hostmap[host] - finally: - self._lock.release() - - def set_ready(self, connection, ready): - try: self._readymap[connection] = ready - except KeyError: pass - - def get_ready_conn(self, host): - conn = None - self._lock.acquire() - try: - if self._hostmap.has_key(host): - for c in self._hostmap[host]: - if self._readymap[c]: - self._readymap[c] = 0 - conn = c - break - finally: - self._lock.release() - return conn - - def get_all(self, host=None): - if host: - return list(self._hostmap.get(host, [])) - else: - return dict(self._hostmap) - -class KeepAliveHandler: - def __init__(self): - self._cm = ConnectionManager() - - #### Connection Management - def open_connections(self): - """return a list of connected hosts and the number of connections - to each. [('foo.com:80', 2), ('bar.org', 1)]""" - return [(host, len(li)) for (host, li) in self._cm.get_all().items()] - - def close_connection(self, host): - """close connection(s) to <host> - host is the host:port spec, as in 'www.cnn.com:8080' as passed in. - no error occurs if there is no connection to that host.""" - for h in self._cm.get_all(host): - self._cm.remove(h) - h.close() - - def close_all(self): - """close all open connections""" - for host, conns in self._cm.get_all().items(): - for h in conns: - self._cm.remove(h) - h.close() - - def _request_closed(self, request, host, connection): - """tells us that this request is now closed and the the - connection is ready for another request""" - self._cm.set_ready(connection, 1) - - def _remove_connection(self, host, connection, close=0): - if close: connection.close() - self._cm.remove(connection) - - #### Transaction Execution - def do_open(self, req): - host = req.get_host() - if not host: - raise urllib2.URLError('no host given') - - try: - h = self._cm.get_ready_conn(host) - while h: - r = self._reuse_connection(h, req, host) - - # if this response is non-None, then it worked and we're - # done. Break out, skipping the else block. - if r: break - - # connection is bad - possibly closed by server - # discard it and ask for the next free connection - h.close() - self._cm.remove(h) - h = self._cm.get_ready_conn(host) - else: - # no (working) free connections were found. Create a new one. - h = self._get_connection(host) - if DEBUG: DEBUG.info("creating new connection to %s (%d)", - host, id(h)) - self._cm.add(host, h, 0) - self._start_transaction(h, req) - r = h.getresponse() - except (socket.error, httplib.HTTPException), err: - raise urllib2.URLError(err) - - # if not a persistent connection, don't try to reuse it - if r.will_close: self._cm.remove(h) - - if DEBUG: DEBUG.info("STATUS: %s, %s", r.status, r.reason) - r._handler = self - r._host = host - r._url = req.get_full_url() - r._connection = h - r.code = r.status - r.headers = r.msg - r.msg = r.reason - - if r.status == 200 or not HANDLE_ERRORS: - return r - else: - return self.parent.error('http', req, r, - r.status, r.msg, r.headers) - - def _reuse_connection(self, h, req, host): - """start the transaction with a re-used connection - return a response object (r) upon success or None on failure. - This DOES not close or remove bad connections in cases where - it returns. However, if an unexpected exception occurs, it - will close and remove the connection before re-raising. - """ - try: - self._start_transaction(h, req) - r = h.getresponse() - # note: just because we got something back doesn't mean it - # worked. We'll check the version below, too. - except (socket.error, httplib.HTTPException): - r = None - except: - # adding this block just in case we've missed - # something we will still raise the exception, but - # lets try and close the connection and remove it - # first. We previously got into a nasty loop - # where an exception was uncaught, and so the - # connection stayed open. On the next try, the - # same exception was raised, etc. The tradeoff is - # that it's now possible this call will raise - # a DIFFERENT exception - if DEBUG: DEBUG.error("unexpected exception - closing " + \ - "connection to %s (%d)", host, id(h)) - self._cm.remove(h) - h.close() - raise - - if r is None or r.version == 9: - # httplib falls back to assuming HTTP 0.9 if it gets a - # bad header back. This is most likely to happen if - # the socket has been closed by the server since we - # last used the connection. - if DEBUG: DEBUG.info("failed to re-use connection to %s (%d)", - host, id(h)) - r = None - else: - if DEBUG: DEBUG.info("re-using connection to %s (%d)", host, id(h)) - - return r - - def _start_transaction(self, h, req): - try: - if req.has_data(): - data = req.get_data() - h.putrequest('POST', req.get_selector()) - if not req.headers.has_key('Content-type'): - h.putheader('Content-type', - 'application/x-www-form-urlencoded') - if not req.headers.has_key('Content-length'): - h.putheader('Content-length', '%d' % len(data)) - else: - h.putrequest('GET', req.get_selector()) - except (socket.error, httplib.HTTPException), err: - raise urllib2.URLError(err) - - for args in self.parent.addheaders: - h.putheader(*args) - for k, v in req.headers.items(): - h.putheader(k, v) - h.endheaders() - if req.has_data(): - h.send(data) - - def _get_connection(self, host): - return NotImplementedError - -class HTTPHandler(KeepAliveHandler, urllib2.HTTPHandler): - def __init__(self): - KeepAliveHandler.__init__(self) - - def http_open(self, req): - return self.do_open(req) - - def _get_connection(self, host): - return HTTPConnection(host) - -class HTTPSHandler(KeepAliveHandler, urllib2.HTTPSHandler): - def __init__(self, ssl_factory=None): - KeepAliveHandler.__init__(self) - if not ssl_factory: - ssl_factory = sslfactory.get_factory() - self._ssl_factory = ssl_factory - - def https_open(self, req): - return self.do_open(req) - - def _get_connection(self, host): - return self._ssl_factory.get_https_connection(host) - -class HTTPResponse(httplib.HTTPResponse): - # we need to subclass HTTPResponse in order to - # 1) add readline() and readlines() methods - # 2) add close_connection() methods - # 3) add info() and geturl() methods - - # in order to add readline(), read must be modified to deal with a - # buffer. example: readline must read a buffer and then spit back - # one line at a time. The only real alternative is to read one - # BYTE at a time (ick). Once something has been read, it can't be - # put back (ok, maybe it can, but that's even uglier than this), - # so if you THEN do a normal read, you must first take stuff from - # the buffer. - - # the read method wraps the original to accomodate buffering, - # although read() never adds to the buffer. - # Both readline and readlines have been stolen with almost no - # modification from socket.py - - - def __init__(self, sock, debuglevel=0, strict=0, method=None): - if method: # the httplib in python 2.3 uses the method arg - httplib.HTTPResponse.__init__(self, sock, debuglevel, method) - else: # 2.2 doesn't - httplib.HTTPResponse.__init__(self, sock, debuglevel) - self.fileno = sock.fileno - self.code = None - self._rbuf = '' - self._rbufsize = 8096 - self._handler = None # inserted by the handler later - self._host = None # (same) - self._url = None # (same) - self._connection = None # (same) - - _raw_read = httplib.HTTPResponse.read - - def close(self): - if self.fp: - self.fp.close() - self.fp = None - if self._handler: - self._handler._request_closed(self, self._host, - self._connection) - - def close_connection(self): - self._handler._remove_connection(self._host, self._connection, close=1) - self.close() - - def info(self): - return self.headers - - def geturl(self): - return self._url - - def read(self, amt=None): - # the _rbuf test is only in this first if for speed. It's not - # logically necessary - if self._rbuf and not amt is None: - L = len(self._rbuf) - if amt > L: - amt -= L - else: - s = self._rbuf[:amt] - self._rbuf = self._rbuf[amt:] - return s - - s = self._rbuf + self._raw_read(amt) - self._rbuf = '' - return s - - def readline(self, limit=-1): - data = "" - i = self._rbuf.find('\n') - while i < 0 and not (0 < limit <= len(self._rbuf)): - new = self._raw_read(self._rbufsize) - if not new: break - i = new.find('\n') - if i >= 0: i = i + len(self._rbuf) - self._rbuf = self._rbuf + new - if i < 0: i = len(self._rbuf) - else: i = i+1 - if 0 <= limit < len(self._rbuf): i = limit - data, self._rbuf = self._rbuf[:i], self._rbuf[i:] - return data - - def readlines(self, sizehint = 0): - total = 0 - list = [] - while 1: - line = self.readline() - if not line: break - list.append(line) - total += len(line) - if sizehint and total >= sizehint: - break - return list - - -class HTTPConnection(httplib.HTTPConnection): - # use the modified response class - response_class = HTTPResponse - -class HTTPSConnection(httplib.HTTPSConnection): - response_class = HTTPResponse - -######################################################################### -##### TEST FUNCTIONS -######################################################################### - -def error_handler(url): - global HANDLE_ERRORS - orig = HANDLE_ERRORS - keepalive_handler = HTTPHandler() - opener = urllib2.build_opener(keepalive_handler) - urllib2.install_opener(opener) - pos = {0: 'off', 1: 'on'} - for i in (0, 1): - print " fancy error handling %s (HANDLE_ERRORS = %i)" % (pos[i], i) - HANDLE_ERRORS = i - try: - fo = urllib2.urlopen(url) - foo = fo.read() - fo.close() - try: status, reason = fo.status, fo.reason - except AttributeError: status, reason = None, None - except IOError, e: - print " EXCEPTION: %s" % e - raise - else: - print " status = %s, reason = %s" % (status, reason) - HANDLE_ERRORS = orig - hosts = keepalive_handler.open_connections() - print "open connections:", hosts - keepalive_handler.close_all() - -def continuity(url): - import md5 - format = '%25s: %s' - - # first fetch the file with the normal http handler - opener = urllib2.build_opener() - urllib2.install_opener(opener) - fo = urllib2.urlopen(url) - foo = fo.read() - fo.close() - m = md5.new(foo) - print format % ('normal urllib', m.hexdigest()) - - # now install the keepalive handler and try again - opener = urllib2.build_opener(HTTPHandler()) - urllib2.install_opener(opener) - - fo = urllib2.urlopen(url) - foo = fo.read() - fo.close() - m = md5.new(foo) - print format % ('keepalive read', m.hexdigest()) - - fo = urllib2.urlopen(url) - foo = '' - while 1: - f = fo.readline() - if f: foo = foo + f - else: break - fo.close() - m = md5.new(foo) - print format % ('keepalive readline', m.hexdigest()) - -def comp(N, url): - print ' making %i connections to:\n %s' % (N, url) - - sys.stdout.write(' first using the normal urllib handlers') - # first use normal opener - opener = urllib2.build_opener() - urllib2.install_opener(opener) - t1 = fetch(N, url) - print ' TIME: %.3f s' % t1 - - sys.stdout.write(' now using the keepalive handler ') - # now install the keepalive handler and try again - opener = urllib2.build_opener(HTTPHandler()) - urllib2.install_opener(opener) - t2 = fetch(N, url) - print ' TIME: %.3f s' % t2 - print ' improvement factor: %.2f' % (t1/t2, ) - -def fetch(N, url, delay=0): - import time - lens = [] - starttime = time.time() - for i in range(N): - if delay and i > 0: time.sleep(delay) - fo = urllib2.urlopen(url) - foo = fo.read() - fo.close() - lens.append(len(foo)) - diff = time.time() - starttime - - j = 0 - for i in lens[1:]: - j = j + 1 - if not i == lens[0]: - print "WARNING: inconsistent length on read %i: %i" % (j, i) - - return diff - -def test_timeout(url): - global DEBUG - dbbackup = DEBUG - class FakeLogger: - def debug(self, msg, *args): print msg % args - info = warning = error = debug - DEBUG = FakeLogger() - print " fetching the file to establish a connection" - fo = urllib2.urlopen(url) - data1 = fo.read() - fo.close() - - i = 20 - print " waiting %i seconds for the server to close the connection" % i - while i > 0: - sys.stdout.write('\r %2i' % i) - sys.stdout.flush() - time.sleep(1) - i -= 1 - sys.stderr.write('\r') - - print " fetching the file a second time" - fo = urllib2.urlopen(url) - data2 = fo.read() - fo.close() - - if data1 == data2: - print ' data are identical' - else: - print ' ERROR: DATA DIFFER' - - DEBUG = dbbackup - - -def test(url, N=10): - print "checking error hander (do this on a non-200)" - try: error_handler(url) - except IOError, e: - print "exiting - exception will prevent further tests" - sys.exit() - print - print "performing continuity test (making sure stuff isn't corrupted)" - continuity(url) - print - print "performing speed comparison" - comp(N, url) - print - print "performing dropped-connection check" - test_timeout(url) - -if __name__ == '__main__': - import time - import sys - try: - N = int(sys.argv[1]) - url = sys.argv[2] - except: - print "%s <integer> <url>" % sys.argv[0] - else: - test(url, N) diff --git a/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/mirror.py b/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/mirror.py deleted file mode 100644 index 9664c6b5c5..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/mirror.py +++ /dev/null @@ -1,458 +0,0 @@ -# This library is free software; you can redistribute it and/or -# modify it under the terms of the GNU Lesser General Public -# License as published by the Free Software Foundation; either -# version 2.1 of the License, or (at your option) any later version. -# -# This library is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Lesser General Public License for more details. -# -# You should have received a copy of the GNU Lesser General Public -# License along with this library; if not, write to the -# Free Software Foundation, Inc., -# 59 Temple Place, Suite 330, -# Boston, MA 02111-1307 USA - -# This file is part of urlgrabber, a high-level cross-protocol url-grabber -# Copyright 2002-2004 Michael D. Stenner, Ryan Tomayko - -"""Module for downloading files from a pool of mirrors - -DESCRIPTION - - This module provides support for downloading files from a pool of - mirrors with configurable failover policies. To a large extent, the - failover policy is chosen by using different classes derived from - the main class, MirrorGroup. - - Instances of MirrorGroup (and cousins) act very much like URLGrabber - instances in that they have urlread, urlgrab, and urlopen methods. - They can therefore, be used in very similar ways. - - from urlgrabber.grabber import URLGrabber - from urlgrabber.mirror import MirrorGroup - gr = URLGrabber() - mg = MirrorGroup(gr, ['http://foo.com/some/directory/', - 'http://bar.org/maybe/somewhere/else/', - 'ftp://baz.net/some/other/place/entirely/'] - mg.urlgrab('relative/path.zip') - - The assumption is that all mirrors are identical AFTER the base urls - specified, so that any mirror can be used to fetch any file. - -FAILOVER - - The failover mechanism is designed to be customized by subclassing - from MirrorGroup to change the details of the behavior. In general, - the classes maintain a master mirror list and a "current mirror" - index. When a download is initiated, a copy of this list and index - is created for that download only. The specific failover policy - depends on the class used, and so is documented in the class - documentation. Note that ANY behavior of the class can be - overridden, so any failover policy at all is possible (although - you may need to change the interface in extreme cases). - -CUSTOMIZATION - - Most customization of a MirrorGroup object is done at instantiation - time (or via subclassing). There are four major types of - customization: - - 1) Pass in a custom urlgrabber - The passed in urlgrabber will be - used (by default... see #2) for the grabs, so options to it - apply for the url-fetching - - 2) Custom mirror list - Mirror lists can simply be a list of - stings mirrors (as shown in the example above) but each can - also be a dict, allowing for more options. For example, the - first mirror in the list above could also have been: - - {'mirror': 'http://foo.com/some/directory/', - 'grabber': <a custom grabber to be used for this mirror>, - 'kwargs': { <a dict of arguments passed to the grabber> }} - - All mirrors are converted to this format internally. If - 'grabber' is omitted, the default grabber will be used. If - kwargs are omitted, then (duh) they will not be used. - - 3) Pass keyword arguments when instantiating the mirror group. - See, for example, the failure_callback argument. - - 4) Finally, any kwargs passed in for the specific file (to the - urlgrab method, for example) will be folded in. The options - passed into the grabber's urlXXX methods will override any - options specified in a custom mirror dict. - -""" - -# $Id: mirror.py,v 1.14 2006/02/22 18:26:46 mstenner Exp $ - -import random -import thread # needed for locking to make this threadsafe - -from grabber import URLGrabError, CallbackObject, DEBUG - -try: - from i18n import _ -except ImportError, msg: - def _(st): return st - -class GrabRequest: - """This is a dummy class used to hold information about the specific - request. For example, a single file. By maintaining this information - separately, we can accomplish two things: - - 1) make it a little easier to be threadsafe - 2) have request-specific parameters - """ - pass - -class MirrorGroup: - """Base Mirror class - - Instances of this class are built with a grabber object and a list - of mirrors. Then all calls to urlXXX should be passed relative urls. - The requested file will be searched for on the first mirror. If the - grabber raises an exception (possibly after some retries) then that - mirror will be removed from the list, and the next will be attempted. - If all mirrors are exhausted, then an exception will be raised. - - MirrorGroup has the following failover policy: - - * downloads begin with the first mirror - - * by default (see default_action below) a failure (after retries) - causes it to increment the local AND master indices. Also, - the current mirror is removed from the local list (but NOT the - master list - the mirror can potentially be used for other - files) - - * if the local list is ever exhausted, a URLGrabError will be - raised (errno=256, no more mirrors) - - OPTIONS - - In addition to the required arguments "grabber" and "mirrors", - MirrorGroup also takes the following optional arguments: - - default_action - - A dict that describes the actions to be taken upon failure - (after retries). default_action can contain any of the - following keys (shown here with their default values): - - default_action = {'increment': 1, - 'increment_master': 1, - 'remove': 1, - 'remove_master': 0, - 'fail': 0} - - In this context, 'increment' means "use the next mirror" and - 'remove' means "never use this mirror again". The two - 'master' values refer to the instance-level mirror list (used - for all files), whereas the non-master values refer to the - current download only. - - The 'fail' option will cause immediate failure by re-raising - the exception and no further attempts to get the current - download. - - This dict can be set at instantiation time, - mg = MirrorGroup(grabber, mirrors, default_action={'fail':1}) - at method-execution time (only applies to current fetch), - filename = mg.urlgrab(url, default_action={'increment': 0}) - or by returning an action dict from the failure_callback - return {'fail':0} - in increasing precedence. - - If all three of these were done, the net result would be: - {'increment': 0, # set in method - 'increment_master': 1, # class default - 'remove': 1, # class default - 'remove_master': 0, # class default - 'fail': 0} # set at instantiation, reset - # from callback - - failure_callback - - this is a callback that will be called when a mirror "fails", - meaning the grabber raises some URLGrabError. If this is a - tuple, it is interpreted to be of the form (cb, args, kwargs) - where cb is the actual callable object (function, method, - etc). Otherwise, it is assumed to be the callable object - itself. The callback will be passed a grabber.CallbackObject - instance along with args and kwargs (if present). The following - attributes are defined withing the instance: - - obj.exception = < exception that was raised > - obj.mirror = < the mirror that was tried > - obj.relative_url = < url relative to the mirror > - obj.url = < full url that failed > - # .url is just the combination of .mirror - # and .relative_url - - The failure callback can return an action dict, as described - above. - - Like default_action, the failure_callback can be set at - instantiation time or when the urlXXX method is called. In - the latter case, it applies only for that fetch. - - The callback can re-raise the exception quite easily. For - example, this is a perfectly adequate callback function: - - def callback(obj): raise obj.exception - - WARNING: do not save the exception object (or the - CallbackObject instance). As they contain stack frame - references, they can lead to circular references. - - Notes: - * The behavior can be customized by deriving and overriding the - 'CONFIGURATION METHODS' - * The 'grabber' instance is kept as a reference, not copied. - Therefore, the grabber instance can be modified externally - and changes will take effect immediately. - """ - - # notes on thread-safety: - - # A GrabRequest should never be shared by multiple threads because - # it's never saved inside the MG object and never returned outside it. - # therefore, it should be safe to access/modify grabrequest data - # without a lock. However, accessing the mirrors and _next attributes - # of the MG itself must be done when locked to prevent (for example) - # removal of the wrong mirror. - - ############################################################## - # CONFIGURATION METHODS - intended to be overridden to - # customize behavior - def __init__(self, grabber, mirrors, **kwargs): - """Initialize the MirrorGroup object. - - REQUIRED ARGUMENTS - - grabber - URLGrabber instance - mirrors - a list of mirrors - - OPTIONAL ARGUMENTS - - failure_callback - callback to be used when a mirror fails - default_action - dict of failure actions - - See the module-level and class level documentation for more - details. - """ - - # OVERRIDE IDEAS: - # shuffle the list to randomize order - self.grabber = grabber - self.mirrors = self._parse_mirrors(mirrors) - self._next = 0 - self._lock = thread.allocate_lock() - self.default_action = None - self._process_kwargs(kwargs) - - # if these values are found in **kwargs passed to one of the urlXXX - # methods, they will be stripped before getting passed on to the - # grabber - options = ['default_action', 'failure_callback'] - - def _process_kwargs(self, kwargs): - self.failure_callback = kwargs.get('failure_callback') - self.default_action = kwargs.get('default_action') - - def _parse_mirrors(self, mirrors): - parsed_mirrors = [] - for m in mirrors: - if type(m) == type(''): m = {'mirror': m} - parsed_mirrors.append(m) - return parsed_mirrors - - def _load_gr(self, gr): - # OVERRIDE IDEAS: - # shuffle gr list - self._lock.acquire() - gr.mirrors = list(self.mirrors) - gr._next = self._next - self._lock.release() - - def _get_mirror(self, gr): - # OVERRIDE IDEAS: - # return a random mirror so that multiple mirrors get used - # even without failures. - if not gr.mirrors: - raise URLGrabError(256, _('No more mirrors to try.')) - return gr.mirrors[gr._next] - - def _failure(self, gr, cb_obj): - # OVERRIDE IDEAS: - # inspect the error - remove=1 for 404, remove=2 for connection - # refused, etc. (this can also be done via - # the callback) - cb = gr.kw.get('failure_callback') or self.failure_callback - if cb: - if type(cb) == type( () ): - cb, args, kwargs = cb - else: - args, kwargs = (), {} - action = cb(cb_obj, *args, **kwargs) or {} - else: - action = {} - # XXXX - decide - there are two ways to do this - # the first is action-overriding as a whole - use the entire action - # or fall back on module level defaults - #action = action or gr.kw.get('default_action') or self.default_action - # the other is to fall through for each element in the action dict - a = dict(self.default_action or {}) - a.update(gr.kw.get('default_action', {})) - a.update(action) - action = a - self.increment_mirror(gr, action) - if action and action.get('fail', 0): raise - - def increment_mirror(self, gr, action={}): - """Tell the mirror object increment the mirror index - - This increments the mirror index, which amounts to telling the - mirror object to use a different mirror (for this and future - downloads). - - This is a SEMI-public method. It will be called internally, - and you may never need to call it. However, it is provided - (and is made public) so that the calling program can increment - the mirror choice for methods like urlopen. For example, with - urlopen, there's no good way for the mirror group to know that - an error occurs mid-download (it's already returned and given - you the file object). - - remove --- can have several values - 0 do not remove the mirror from the list - 1 remove the mirror for this download only - 2 remove the mirror permanently - - beware of remove=0 as it can lead to infinite loops - """ - badmirror = gr.mirrors[gr._next] - - self._lock.acquire() - try: - ind = self.mirrors.index(badmirror) - except ValueError: - pass - else: - if action.get('remove_master', 0): - del self.mirrors[ind] - elif self._next == ind and action.get('increment_master', 1): - self._next += 1 - if self._next >= len(self.mirrors): self._next = 0 - self._lock.release() - - if action.get('remove', 1): - del gr.mirrors[gr._next] - elif action.get('increment', 1): - gr._next += 1 - if gr._next >= len(gr.mirrors): gr._next = 0 - - if DEBUG: - grm = [m['mirror'] for m in gr.mirrors] - DEBUG.info('GR mirrors: [%s] %i', ' '.join(grm), gr._next) - selfm = [m['mirror'] for m in self.mirrors] - DEBUG.info('MAIN mirrors: [%s] %i', ' '.join(selfm), self._next) - - ##################################################################### - # NON-CONFIGURATION METHODS - # these methods are designed to be largely workhorse methods that - # are not intended to be overridden. That doesn't mean you can't; - # if you want to, feel free, but most things can be done by - # by overriding the configuration methods :) - - def _join_url(self, base_url, rel_url): - if base_url.endswith('/') or rel_url.startswith('/'): - return base_url + rel_url - else: - return base_url + '/' + rel_url - - def _mirror_try(self, func, url, kw): - gr = GrabRequest() - gr.func = func - gr.url = url - gr.kw = dict(kw) - self._load_gr(gr) - - for k in self.options: - try: del kw[k] - except KeyError: pass - - while 1: - mirrorchoice = self._get_mirror(gr) - fullurl = self._join_url(mirrorchoice['mirror'], gr.url) - kwargs = dict(mirrorchoice.get('kwargs', {})) - kwargs.update(kw) - grabber = mirrorchoice.get('grabber') or self.grabber - func_ref = getattr(grabber, func) - if DEBUG: DEBUG.info('MIRROR: trying %s -> %s', url, fullurl) - try: - return func_ref( *(fullurl,), **kwargs ) - except URLGrabError, e: - if DEBUG: DEBUG.info('MIRROR: failed') - obj = CallbackObject() - obj.exception = e - obj.mirror = mirrorchoice['mirror'] - obj.relative_url = gr.url - obj.url = fullurl - self._failure(gr, obj) - - def urlgrab(self, url, filename=None, **kwargs): - kw = dict(kwargs) - kw['filename'] = filename - func = 'urlgrab' - return self._mirror_try(func, url, kw) - - def urlopen(self, url, **kwargs): - kw = dict(kwargs) - func = 'urlopen' - return self._mirror_try(func, url, kw) - - def urlread(self, url, limit=None, **kwargs): - kw = dict(kwargs) - kw['limit'] = limit - func = 'urlread' - return self._mirror_try(func, url, kw) - - -class MGRandomStart(MirrorGroup): - """A mirror group that starts at a random mirror in the list. - - This behavior of this class is identical to MirrorGroup, except that - it starts at a random location in the mirror list. - """ - - def __init__(self, grabber, mirrors, **kwargs): - """Initialize the object - - The arguments for intialization are the same as for MirrorGroup - """ - MirrorGroup.__init__(self, grabber, mirrors, **kwargs) - self._next = random.randrange(len(mirrors)) - -class MGRandomOrder(MirrorGroup): - """A mirror group that uses mirrors in a random order. - - This behavior of this class is identical to MirrorGroup, except that - it uses the mirrors in a random order. Note that the order is set at - initialization time and fixed thereafter. That is, it does not pick a - random mirror after each failure. - """ - - def __init__(self, grabber, mirrors, **kwargs): - """Initialize the object - - The arguments for intialization are the same as for MirrorGroup - """ - MirrorGroup.__init__(self, grabber, mirrors, **kwargs) - random.shuffle(self.mirrors) - -if __name__ == '__main__': - pass diff --git a/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/progress.py b/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/progress.py deleted file mode 100644 index 02db524e76..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/progress.py +++ /dev/null @@ -1,530 +0,0 @@ -# This library is free software; you can redistribute it and/or -# modify it under the terms of the GNU Lesser General Public -# License as published by the Free Software Foundation; either -# version 2.1 of the License, or (at your option) any later version. -# -# This library is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Lesser General Public License for more details. -# -# You should have received a copy of the GNU Lesser General Public -# License along with this library; if not, write to the -# Free Software Foundation, Inc., -# 59 Temple Place, Suite 330, -# Boston, MA 02111-1307 USA - -# This file is part of urlgrabber, a high-level cross-protocol url-grabber -# Copyright 2002-2004 Michael D. Stenner, Ryan Tomayko - -# $Id: progress.py,v 1.7 2005/08/19 21:59:07 mstenner Exp $ - -import sys -import time -import math -import thread - -class BaseMeter: - def __init__(self): - self.update_period = 0.3 # seconds - - self.filename = None - self.url = None - self.basename = None - self.text = None - self.size = None - self.start_time = None - self.last_amount_read = 0 - self.last_update_time = None - self.re = RateEstimator() - - def start(self, filename=None, url=None, basename=None, - size=None, now=None, text=None): - self.filename = filename - self.url = url - self.basename = basename - self.text = text - - #size = None ######### TESTING - self.size = size - if not size is None: self.fsize = format_number(size) + 'B' - - if now is None: now = time.time() - self.start_time = now - self.re.start(size, now) - self.last_amount_read = 0 - self.last_update_time = now - self._do_start(now) - - def _do_start(self, now=None): - pass - - def update(self, amount_read, now=None): - # for a real gui, you probably want to override and put a call - # to your mainloop iteration function here - if now is None: now = time.time() - if (now >= self.last_update_time + self.update_period) or \ - not self.last_update_time: - self.re.update(amount_read, now) - self.last_amount_read = amount_read - self.last_update_time = now - self._do_update(amount_read, now) - - def _do_update(self, amount_read, now=None): - pass - - def end(self, amount_read, now=None): - if now is None: now = time.time() - self.re.update(amount_read, now) - self.last_amount_read = amount_read - self.last_update_time = now - self._do_end(amount_read, now) - - def _do_end(self, amount_read, now=None): - pass - -class TextMeter(BaseMeter): - def __init__(self, fo=sys.stderr): - BaseMeter.__init__(self) - self.fo = fo - - def _do_update(self, amount_read, now=None): - etime = self.re.elapsed_time() - fetime = format_time(etime) - fread = format_number(amount_read) - #self.size = None - if self.text is not None: - text = self.text - else: - text = self.basename - if self.size is None: - out = '\r%-60.60s %5sB %s ' % \ - (text, fread, fetime) - else: - rtime = self.re.remaining_time() - frtime = format_time(rtime) - frac = self.re.fraction_read() - bar = '='*int(25 * frac) - - out = '\r%-25.25s %3i%% |%-25.25s| %5sB %8s ETA ' % \ - (text, frac*100, bar, fread, frtime) - - self.fo.write(out) - self.fo.flush() - - def _do_end(self, amount_read, now=None): - total_time = format_time(self.re.elapsed_time()) - total_size = format_number(amount_read) - if self.text is not None: - text = self.text - else: - text = self.basename - if self.size is None: - out = '\r%-60.60s %5sB %s ' % \ - (text, total_size, total_time) - else: - bar = '='*25 - out = '\r%-25.25s %3i%% |%-25.25s| %5sB %8s ' % \ - (text, 100, bar, total_size, total_time) - self.fo.write(out + '\n') - self.fo.flush() - -text_progress_meter = TextMeter - -class MultiFileHelper(BaseMeter): - def __init__(self, master): - BaseMeter.__init__(self) - self.master = master - - def _do_start(self, now): - self.master.start_meter(self, now) - - def _do_update(self, amount_read, now): - # elapsed time since last update - self.master.update_meter(self, now) - - def _do_end(self, amount_read, now): - self.ftotal_time = format_time(now - self.start_time) - self.ftotal_size = format_number(self.last_amount_read) - self.master.end_meter(self, now) - - def failure(self, message, now=None): - self.master.failure_meter(self, message, now) - - def message(self, message): - self.master.message_meter(self, message) - -class MultiFileMeter: - helperclass = MultiFileHelper - def __init__(self): - self.meters = [] - self.in_progress_meters = [] - self._lock = thread.allocate_lock() - self.update_period = 0.3 # seconds - - self.numfiles = None - self.finished_files = 0 - self.failed_files = 0 - self.open_files = 0 - self.total_size = None - self.failed_size = 0 - self.start_time = None - self.finished_file_size = 0 - self.last_update_time = None - self.re = RateEstimator() - - def start(self, numfiles=None, total_size=None, now=None): - if now is None: now = time.time() - self.numfiles = numfiles - self.finished_files = 0 - self.failed_files = 0 - self.open_files = 0 - self.total_size = total_size - self.failed_size = 0 - self.start_time = now - self.finished_file_size = 0 - self.last_update_time = now - self.re.start(total_size, now) - self._do_start(now) - - def _do_start(self, now): - pass - - def end(self, now=None): - if now is None: now = time.time() - self._do_end(now) - - def _do_end(self, now): - pass - - def lock(self): self._lock.acquire() - def unlock(self): self._lock.release() - - ########################################################### - # child meter creation and destruction - def newMeter(self): - newmeter = self.helperclass(self) - self.meters.append(newmeter) - return newmeter - - def removeMeter(self, meter): - self.meters.remove(meter) - - ########################################################### - # child functions - these should only be called by helpers - def start_meter(self, meter, now): - if not meter in self.meters: - raise ValueError('attempt to use orphaned meter') - self._lock.acquire() - try: - if not meter in self.in_progress_meters: - self.in_progress_meters.append(meter) - self.open_files += 1 - finally: - self._lock.release() - self._do_start_meter(meter, now) - - def _do_start_meter(self, meter, now): - pass - - def update_meter(self, meter, now): - if not meter in self.meters: - raise ValueError('attempt to use orphaned meter') - if (now >= self.last_update_time + self.update_period) or \ - not self.last_update_time: - self.re.update(self._amount_read(), now) - self.last_update_time = now - self._do_update_meter(meter, now) - - def _do_update_meter(self, meter, now): - pass - - def end_meter(self, meter, now): - if not meter in self.meters: - raise ValueError('attempt to use orphaned meter') - self._lock.acquire() - try: - try: self.in_progress_meters.remove(meter) - except ValueError: pass - self.open_files -= 1 - self.finished_files += 1 - self.finished_file_size += meter.last_amount_read - finally: - self._lock.release() - self._do_end_meter(meter, now) - - def _do_end_meter(self, meter, now): - pass - - def failure_meter(self, meter, message, now): - if not meter in self.meters: - raise ValueError('attempt to use orphaned meter') - self._lock.acquire() - try: - try: self.in_progress_meters.remove(meter) - except ValueError: pass - self.open_files -= 1 - self.failed_files += 1 - if meter.size and self.failed_size is not None: - self.failed_size += meter.size - else: - self.failed_size = None - finally: - self._lock.release() - self._do_failure_meter(meter, message, now) - - def _do_failure_meter(self, meter, message, now): - pass - - def message_meter(self, meter, message): - pass - - ######################################################## - # internal functions - def _amount_read(self): - tot = self.finished_file_size - for m in self.in_progress_meters: - tot += m.last_amount_read - return tot - - -class TextMultiFileMeter(MultiFileMeter): - def __init__(self, fo=sys.stderr): - self.fo = fo - MultiFileMeter.__init__(self) - - # files: ###/### ###% data: ######/###### ###% time: ##:##:##/##:##:## - def _do_update_meter(self, meter, now): - self._lock.acquire() - try: - format = "files: %3i/%-3i %3i%% data: %6.6s/%-6.6s %3i%% " \ - "time: %8.8s/%8.8s" - df = self.finished_files - tf = self.numfiles or 1 - pf = 100 * float(df)/tf + 0.49 - dd = self.re.last_amount_read - td = self.total_size - pd = 100 * (self.re.fraction_read() or 0) + 0.49 - dt = self.re.elapsed_time() - rt = self.re.remaining_time() - if rt is None: tt = None - else: tt = dt + rt - - fdd = format_number(dd) + 'B' - ftd = format_number(td) + 'B' - fdt = format_time(dt, 1) - ftt = format_time(tt, 1) - - out = '%-79.79s' % (format % (df, tf, pf, fdd, ftd, pd, fdt, ftt)) - self.fo.write('\r' + out) - self.fo.flush() - finally: - self._lock.release() - - def _do_end_meter(self, meter, now): - self._lock.acquire() - try: - format = "%-30.30s %6.6s %8.8s %9.9s" - fn = meter.basename - size = meter.last_amount_read - fsize = format_number(size) + 'B' - et = meter.re.elapsed_time() - fet = format_time(et, 1) - frate = format_number(size / et) + 'B/s' - - out = '%-79.79s' % (format % (fn, fsize, fet, frate)) - self.fo.write('\r' + out + '\n') - finally: - self._lock.release() - self._do_update_meter(meter, now) - - def _do_failure_meter(self, meter, message, now): - self._lock.acquire() - try: - format = "%-30.30s %6.6s %s" - fn = meter.basename - if type(message) in (type(''), type(u'')): - message = message.splitlines() - if not message: message = [''] - out = '%-79s' % (format % (fn, 'FAILED', message[0] or '')) - self.fo.write('\r' + out + '\n') - for m in message[1:]: self.fo.write(' ' + m + '\n') - self._lock.release() - finally: - self._do_update_meter(meter, now) - - def message_meter(self, meter, message): - self._lock.acquire() - try: - pass - finally: - self._lock.release() - - def _do_end(self, now): - self._do_update_meter(None, now) - self._lock.acquire() - try: - self.fo.write('\n') - self.fo.flush() - finally: - self._lock.release() - -###################################################################### -# support classes and functions - -class RateEstimator: - def __init__(self, timescale=5.0): - self.timescale = timescale - - def start(self, total=None, now=None): - if now is None: now = time.time() - self.total = total - self.start_time = now - self.last_update_time = now - self.last_amount_read = 0 - self.ave_rate = None - - def update(self, amount_read, now=None): - if now is None: now = time.time() - if amount_read == 0: - # if we just started this file, all bets are off - self.last_update_time = now - self.last_amount_read = 0 - self.ave_rate = None - return - - #print 'times', now, self.last_update_time - time_diff = now - self.last_update_time - read_diff = amount_read - self.last_amount_read - self.last_update_time = now - self.last_amount_read = amount_read - self.ave_rate = self._temporal_rolling_ave(\ - time_diff, read_diff, self.ave_rate, self.timescale) - #print 'results', time_diff, read_diff, self.ave_rate - - ##################################################################### - # result methods - def average_rate(self): - "get the average transfer rate (in bytes/second)" - return self.ave_rate - - def elapsed_time(self): - "the time between the start of the transfer and the most recent update" - return self.last_update_time - self.start_time - - def remaining_time(self): - "estimated time remaining" - if not self.ave_rate or not self.total: return None - return (self.total - self.last_amount_read) / self.ave_rate - - def fraction_read(self): - """the fraction of the data that has been read - (can be None for unknown transfer size)""" - if self.total is None: return None - elif self.total == 0: return 1.0 - else: return float(self.last_amount_read)/self.total - - ######################################################################### - # support methods - def _temporal_rolling_ave(self, time_diff, read_diff, last_ave, timescale): - """a temporal rolling average performs smooth averaging even when - updates come at irregular intervals. This is performed by scaling - the "epsilon" according to the time since the last update. - Specifically, epsilon = time_diff / timescale - - As a general rule, the average will take on a completely new value - after 'timescale' seconds.""" - epsilon = time_diff / timescale - if epsilon > 1: epsilon = 1.0 - return self._rolling_ave(time_diff, read_diff, last_ave, epsilon) - - def _rolling_ave(self, time_diff, read_diff, last_ave, epsilon): - """perform a "rolling average" iteration - a rolling average "folds" new data into an existing average with - some weight, epsilon. epsilon must be between 0.0 and 1.0 (inclusive) - a value of 0.0 means only the old value (initial value) counts, - and a value of 1.0 means only the newest value is considered.""" - - try: - recent_rate = read_diff / time_diff - except ZeroDivisionError: - recent_rate = None - if last_ave is None: return recent_rate - elif recent_rate is None: return last_ave - - # at this point, both last_ave and recent_rate are numbers - return epsilon * recent_rate + (1 - epsilon) * last_ave - - def _round_remaining_time(self, rt, start_time=15.0): - """round the remaining time, depending on its size - If rt is between n*start_time and (n+1)*start_time round downward - to the nearest multiple of n (for any counting number n). - If rt < start_time, round down to the nearest 1. - For example (for start_time = 15.0): - 2.7 -> 2.0 - 25.2 -> 25.0 - 26.4 -> 26.0 - 35.3 -> 34.0 - 63.6 -> 60.0 - """ - - if rt < 0: return 0.0 - shift = int(math.log(rt/start_time)/math.log(2)) - rt = int(rt) - if shift <= 0: return rt - return float(int(rt) >> shift << shift) - - -def format_time(seconds, use_hours=0): - if seconds is None or seconds < 0: - if use_hours: return '--:--:--' - else: return '--:--' - else: - seconds = int(seconds) - minutes = seconds / 60 - seconds = seconds % 60 - if use_hours: - hours = minutes / 60 - minutes = minutes % 60 - return '%02i:%02i:%02i' % (hours, minutes, seconds) - else: - return '%02i:%02i' % (minutes, seconds) - -def format_number(number, SI=0, space=' '): - """Turn numbers into human-readable metric-like numbers""" - symbols = ['', # (none) - 'k', # kilo - 'M', # mega - 'G', # giga - 'T', # tera - 'P', # peta - 'E', # exa - 'Z', # zetta - 'Y'] # yotta - - if SI: step = 1000.0 - else: step = 1024.0 - - thresh = 999 - depth = 0 - max_depth = len(symbols) - 1 - - # we want numbers between 0 and thresh, but don't exceed the length - # of our list. In that event, the formatting will be screwed up, - # but it'll still show the right number. - while number > thresh and depth < max_depth: - depth = depth + 1 - number = number / step - - if type(number) == type(1) or type(number) == type(1L): - # it's an int or a long, which means it didn't get divided, - # which means it's already short enough - format = '%i%s%s' - elif number < 9.95: - # must use 9.95 for proper sizing. For example, 9.99 will be - # rounded to 10.0 with the .1f format string (which is too long) - format = '%.1f%s%s' - else: - format = '%.0f%s%s' - - return(format % (float(number or 0), space, symbols[depth])) diff --git a/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/sslfactory.py b/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/sslfactory.py deleted file mode 100644 index 07848dac7c..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/sslfactory.py +++ /dev/null @@ -1,90 +0,0 @@ -# This library is free software; you can redistribute it and/or -# modify it under the terms of the GNU Lesser General Public -# License as published by the Free Software Foundation; either -# version 2.1 of the License, or (at your option) any later version. -# -# This library is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Lesser General Public License for more details. -# -# You should have received a copy of the GNU Lesser General Public -# License along with this library; if not, write to the -# Free Software Foundation, Inc., -# 59 Temple Place, Suite 330, -# Boston, MA 02111-1307 USA - -# This file is part of urlgrabber, a high-level cross-protocol url-grabber - -import httplib -import urllib2 - -try: - from M2Crypto import SSL - from M2Crypto import httpslib - from M2Crypto import m2urllib2 - - SSL.Connection.clientPostConnectionCheck = None - have_m2crypto = True -except ImportError: - have_m2crypto = False - -DEBUG = None - -if have_m2crypto: - - class M2SSLFactory: - - def __init__(self, ssl_ca_cert, ssl_context): - self.ssl_context = self._get_ssl_context(ssl_ca_cert, ssl_context) - - def _get_ssl_context(self, ssl_ca_cert, ssl_context): - """ - Create an ssl context using the CA cert file or ssl context. - - The CA cert is used first if it was passed as an option. If not, - then the supplied ssl context is used. If no ssl context was supplied, - None is returned. - """ - if ssl_ca_cert: - context = SSL.Context() - context.load_verify_locations(ssl_ca_cert) - context.set_verify(SSL.verify_none, -1) - return context - else: - return ssl_context - - def create_https_connection(self, host, response_class = None): - connection = httplib.HTTPSConnection(host, self.ssl_context) - if response_class: - connection.response_class = response_class - return connection - - def create_opener(self, *handlers): - return m2urllib2.build_opener(self.ssl_context, *handlers) - - -class SSLFactory: - - def create_https_connection(self, host, response_class = None): - connection = httplib.HTTPSConnection(host) - if response_class: - connection.response_class = response_class - return connection - - def create_opener(self, *handlers): - return urllib2.build_opener(*handlers) - - - -def get_factory(ssl_ca_cert = None, ssl_context = None): - """ Return an SSLFactory, based on if M2Crypto is available. """ - if have_m2crypto: - return M2SSLFactory(ssl_ca_cert, ssl_context) - else: - # Log here if someone provides the args but we don't use them. - if ssl_ca_cert or ssl_context: - if DEBUG: - DEBUG.warning("SSL arguments supplied, but M2Crypto is not available. " - "Using Python SSL.") - return SSLFactory() diff --git a/scripts/lib/mic/3rdparty/pykickstart/version.py b/scripts/lib/mic/3rdparty/pykickstart/version.py deleted file mode 100644 index 102cc37d80..0000000000 --- a/scripts/lib/mic/3rdparty/pykickstart/version.py +++ /dev/null @@ -1,197 +0,0 @@ -# -# Chris Lumens <clumens@redhat.com> -# -# Copyright 2006, 2007, 2008, 2009, 2010 Red Hat, Inc. -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat -# trademarks that are incorporated in the source code or documentation are not -# subject to the GNU General Public License and may only be used or replicated -# with the express permission of Red Hat, Inc. -# -""" -Methods for working with kickstart versions. - -This module defines several symbolic constants that specify kickstart syntax -versions. Each version corresponds roughly to one release of Red Hat Linux, -Red Hat Enterprise Linux, or Fedora Core as these are where most syntax -changes take place. - -This module also exports several functions: - - makeVersion - Given a version number, return an instance of the - matching handler class. - - returnClassForVersion - Given a version number, return the matching - handler class. This does not return an - instance of that class, however. - - stringToVersion - Convert a string representation of a version number - into the symbolic constant. - - versionToString - Perform the reverse mapping. - - versionFromFile - Read a kickstart file and determine the version of - syntax it uses. This requires the kickstart file to - have a version= comment in it. -""" -import imputil, re, sys -from urlgrabber import urlopen - -import gettext -_ = lambda x: gettext.ldgettext("pykickstart", x) - -from pykickstart.errors import KickstartVersionError - -# Symbolic names for internal version numbers. -RHEL3 = 900 -FC3 = 1000 -RHEL4 = 1100 -FC4 = 2000 -FC5 = 3000 -FC6 = 4000 -RHEL5 = 4100 -F7 = 5000 -F8 = 6000 -F9 = 7000 -F10 = 8000 -F11 = 9000 -F12 = 10000 -F13 = 11000 -RHEL6 = 11100 -F14 = 12000 -F15 = 13000 -F16 = 14000 - -# This always points at the latest version and is the default. -DEVEL = F16 - -# A one-to-one mapping from string representations to version numbers. -versionMap = { - "DEVEL": DEVEL, - "FC3": FC3, "FC4": FC4, "FC5": FC5, "FC6": FC6, "F7": F7, "F8": F8, - "F9": F9, "F10": F10, "F11": F11, "F12": F12, "F13": F13, - "F14": F14, "F15": F15, "F16": F16, - "RHEL3": RHEL3, "RHEL4": RHEL4, "RHEL5": RHEL5, "RHEL6": RHEL6 -} - -def stringToVersion(s): - """Convert string into one of the provided version constants. Raises - KickstartVersionError if string does not match anything. - """ - # First try these short forms. - try: - return versionMap[s.upper()] - except KeyError: - pass - - # Now try the Fedora versions. - m = re.match("^fedora.* (\d+)$", s, re.I) - - if m and m.group(1): - if versionMap.has_key("FC" + m.group(1)): - return versionMap["FC" + m.group(1)] - elif versionMap.has_key("F" + m.group(1)): - return versionMap["F" + m.group(1)] - else: - raise KickstartVersionError(_("Unsupported version specified: %s") % s) - - # Now try the RHEL versions. - m = re.match("^red hat enterprise linux.* (\d+)([\.\d]*)$", s, re.I) - - if m and m.group(1): - if versionMap.has_key("RHEL" + m.group(1)): - return versionMap["RHEL" + m.group(1)] - else: - raise KickstartVersionError(_("Unsupported version specified: %s") % s) - - # If nothing else worked, we're out of options. - raise KickstartVersionError(_("Unsupported version specified: %s") % s) - -def versionToString(version, skipDevel=False): - """Convert version into a string representation of the version number. - This is the reverse operation of stringToVersion. Raises - KickstartVersionError if version does not match anything. - """ - if not skipDevel and version == versionMap["DEVEL"]: - return "DEVEL" - - for (key, val) in versionMap.iteritems(): - if key == "DEVEL": - continue - elif val == version: - return key - - raise KickstartVersionError(_("Unsupported version specified: %s") % version) - -def versionFromFile(f): - """Given a file or URL, look for a line starting with #version= and - return the version number. If no version is found, return DEVEL. - """ - v = DEVEL - - fh = urlopen(f) - - while True: - try: - l = fh.readline() - except StopIteration: - break - - # At the end of the file? - if l == "": - break - - if l.isspace() or l.strip() == "": - continue - - if l[:9] == "#version=": - v = stringToVersion(l[9:].rstrip()) - break - - fh.close() - return v - -def returnClassForVersion(version=DEVEL): - """Return the class of the syntax handler for version. version can be - either a string or the matching constant. Raises KickstartValueError - if version does not match anything. - """ - try: - version = int(version) - module = "%s" % versionToString(version, skipDevel=True) - except ValueError: - module = "%s" % version - version = stringToVersion(version) - - module = module.lower() - - try: - import pykickstart.handlers - sys.path.extend(pykickstart.handlers.__path__) - found = imputil.imp.find_module(module) - loaded = imputil.imp.load_module(module, found[0], found[1], found[2]) - - for (k, v) in loaded.__dict__.iteritems(): - if k.lower().endswith("%shandler" % module): - return v - except: - raise KickstartVersionError(_("Unsupported version specified: %s") % version) - -def makeVersion(version=DEVEL): - """Return a new instance of the syntax handler for version. version can be - either a string or the matching constant. This function is useful for - standalone programs which just need to handle a specific version of - kickstart syntax (as provided by a command line argument, for example) - and need to instantiate the correct object. - """ - cl = returnClassForVersion(version) - return cl() diff --git a/scripts/lib/mic/__init__.py b/scripts/lib/mic/__init__.py deleted file mode 100644 index 63c1d9c846..0000000000 --- a/scripts/lib/mic/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -import os, sys - -cur_path = os.path.dirname(__file__) or '.' -sys.path.insert(0, cur_path + '/3rdparty') diff --git a/scripts/lib/mic/__version__.py b/scripts/lib/mic/__version__.py deleted file mode 100644 index 60d7626cac..0000000000 --- a/scripts/lib/mic/__version__.py +++ /dev/null @@ -1 +0,0 @@ -VERSION = "0.14" diff --git a/scripts/lib/mic/bootstrap.py b/scripts/lib/mic/bootstrap.py deleted file mode 100644 index 66c291b0a8..0000000000 --- a/scripts/lib/mic/bootstrap.py +++ /dev/null @@ -1,279 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2009, 2010, 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -from __future__ import with_statement -import os -import sys -import tempfile -import shutil -import subprocess -import rpm -from mic import msger -from mic.utils import errors, proxy, misc -from mic.utils.rpmmisc import readRpmHeader, RPMInstallCallback -from mic.chroot import cleanup_mounts, setup_chrootenv, cleanup_chrootenv - -PATH_BOOTSTRAP = "/usr/sbin:/usr/bin:/sbin:/bin" - -RPMTRANS_FLAGS = [ - rpm.RPMTRANS_FLAG_ALLFILES, - rpm.RPMTRANS_FLAG_NOSCRIPTS, - rpm.RPMTRANS_FLAG_NOTRIGGERS, - ] - -RPMVSF_FLAGS = [ - rpm._RPMVSF_NOSIGNATURES, - rpm._RPMVSF_NODIGESTS - ] - -RPMPROB_FLAGS = [ - rpm.RPMPROB_FILTER_OLDPACKAGE, - rpm.RPMPROB_FILTER_REPLACEPKG, - rpm.RPMPROB_FILTER_IGNOREARCH - ] - -class MiniBackend(object): - def __init__(self, rootdir, arch=None, repomd=None): - self._ts = None - self.rootdir = os.path.abspath(rootdir) - self.arch = arch - self.repomd = repomd - self.dlpkgs = [] - self.localpkgs = {} - self.optionals = [] - self.preins = {} - self.postins = {} - self.scriptlets = False - - def __del__(self): - try: - del self.ts - except: - pass - - def get_ts(self): - if not self._ts: - self._ts = rpm.TransactionSet(self.rootdir) - self._ts.setFlags(reduce(lambda x, y: x|y, RPMTRANS_FLAGS)) - self._ts.setVSFlags(reduce(lambda x, y: x|y, RPMVSF_FLAGS)) - self._ts.setProbFilter(reduce(lambda x, y: x|y, RPMPROB_FLAGS)) - - return self._ts - - def del_ts(self): - if self._ts: - self._ts.closeDB() - self._ts = None - - ts = property(fget = lambda self: self.get_ts(), - fdel = lambda self: self.del_ts(), - doc="TransactionSet object") - - def selectPackage(self, pkg): - if not pkg in self.dlpkgs: - self.dlpkgs.append(pkg) - - def runInstall(self): - # FIXME: check space - self.downloadPkgs() - self.installPkgs() - - if not self.scriptlets: - return - - for pkg in self.preins.keys(): - prog, script = self.preins[pkg] - self.run_pkg_script(pkg, prog, script, '0') - for pkg in self.postins.keys(): - prog, script = self.postins[pkg] - self.run_pkg_script(pkg, prog, script, '1') - - def downloadPkgs(self): - nonexist = [] - for pkg in self.dlpkgs: - localpth = misc.get_package(pkg, self.repomd, self.arch) - if localpth: - self.localpkgs[pkg] = localpth - elif pkg in self.optionals: - # skip optional rpm - continue - else: - # mark nonexist rpm - nonexist.append(pkg) - - if nonexist: - raise errors.BootstrapError("Can't get rpm binary: %s" % - ','.join(nonexist)) - - def installPkgs(self): - for pkg in self.localpkgs.keys(): - rpmpath = self.localpkgs[pkg] - - hdr = readRpmHeader(self.ts, rpmpath) - - # save prein and postin scripts - self.preins[pkg] = (hdr['PREINPROG'], hdr['PREIN']) - self.postins[pkg] = (hdr['POSTINPROG'], hdr['POSTIN']) - - # mark pkg as install - self.ts.addInstall(hdr, rpmpath, 'u') - - # run transaction - self.ts.order() - cb = RPMInstallCallback(self.ts) - self.ts.run(cb.callback, '') - - def run_pkg_script(self, pkg, prog, script, arg): - mychroot = lambda: os.chroot(self.rootdir) - - if not script: - return - - if prog == "<lua>": - prog = "/usr/bin/lua" - - tmpdir = os.path.join(self.rootdir, "tmp") - if not os.path.exists(tmpdir): - os.makedirs(tmpdir) - tmpfd, tmpfp = tempfile.mkstemp(dir=tmpdir, prefix="%s.pre-" % pkg) - script = script.replace('\r', '') - os.write(tmpfd, script) - os.close(tmpfd) - os.chmod(tmpfp, 0700) - - try: - script_fp = os.path.join('/tmp', os.path.basename(tmpfp)) - subprocess.call([prog, script_fp, arg], preexec_fn=mychroot) - except (OSError, IOError), err: - msger.warning(str(err)) - finally: - os.unlink(tmpfp) - -class Bootstrap(object): - def __init__(self, rootdir, distro, arch=None): - self.rootdir = misc.mkdtemp(dir=rootdir, prefix=distro) - self.distro = distro - self.arch = arch - self.logfile = None - self.pkgslist = [] - self.repomd = None - - def __del__(self): - self.cleanup() - - def get_rootdir(self): - if os.path.exists(self.rootdir): - shutil.rmtree(self.rootdir, ignore_errors=True) - os.makedirs(self.rootdir) - return self.rootdir - - def dirsetup(self, rootdir=None): - _path = lambda pth: os.path.join(rootdir, pth.lstrip('/')) - - if not rootdir: - rootdir = self.rootdir - - try: - # make /tmp and /etc path - tmpdir = _path('/tmp') - if not os.path.exists(tmpdir): - os.makedirs(tmpdir) - etcdir = _path('/etc') - if not os.path.exists(etcdir): - os.makedirs(etcdir) - - # touch distro file - tzdist = _path('/etc/%s-release' % self.distro) - if not os.path.exists(tzdist): - with open(tzdist, 'w') as wf: - wf.write("bootstrap") - except: - pass - - def create(self, repomd, pkglist, optlist=()): - try: - pkgmgr = MiniBackend(self.get_rootdir()) - pkgmgr.arch = self.arch - pkgmgr.repomd = repomd - pkgmgr.optionals = list(optlist) - map(pkgmgr.selectPackage, pkglist + list(optlist)) - pkgmgr.runInstall() - except (OSError, IOError, errors.CreatorError), err: - raise errors.BootstrapError("%s" % err) - - def run(self, cmd, chdir, rootdir=None, bindmounts=None): - def mychroot(): - os.chroot(rootdir) - os.chdir(chdir) - - def sync_timesetting(rootdir): - try: - # sync time and zone info to bootstrap - if os.path.exists(rootdir + "/etc/localtime"): - os.unlink(rootdir + "/etc/localtime") - shutil.copyfile("/etc/localtime", rootdir + "/etc/localtime") - except: - pass - - def sync_passwdfile(rootdir): - try: - # sync passwd file to bootstrap, saving the user info - if os.path.exists(rootdir + "/etc/passwd"): - os.unlink(rootdir + "/etc/passwd") - shutil.copyfile("/etc/passwd", rootdir + "/etc/passwd") - except: - pass - - if not rootdir: - rootdir = self.rootdir - - if isinstance(cmd, list): - shell = False - else: - shell = True - - env = os.environ - env['PATH'] = "%s:%s" % (PATH_BOOTSTRAP, env['PATH']) - - retcode = 0 - gloablmounts = None - try: - proxy.set_proxy_environ() - gloablmounts = setup_chrootenv(rootdir, bindmounts, False) - sync_timesetting(rootdir) - sync_passwdfile(rootdir) - retcode = subprocess.call(cmd, preexec_fn=mychroot, env=env, shell=shell) - except (OSError, IOError): - # add additional information to original exception - value, tb = sys.exc_info()[1:] - value = '%s: %s' % (value, ' '.join(cmd)) - raise RuntimeError, value, tb - finally: - if self.logfile and os.path.isfile(self.logfile): - msger.log(file(self.logfile).read()) - cleanup_chrootenv(rootdir, bindmounts, gloablmounts) - proxy.unset_proxy_environ() - return retcode - - def cleanup(self): - try: - # clean mounts - cleanup_mounts(self.rootdir) - # remove rootdir - shutil.rmtree(self.rootdir, ignore_errors=True) - except: - pass diff --git a/scripts/lib/mic/chroot.py b/scripts/lib/mic/chroot.py deleted file mode 100644 index 99fb9a2c17..0000000000 --- a/scripts/lib/mic/chroot.py +++ /dev/null @@ -1,343 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2009, 2010, 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -from __future__ import with_statement -import os -import shutil -import subprocess - -from mic import msger -from mic.conf import configmgr -from mic.utils import misc, errors, runner, fs_related - -chroot_lockfd = -1 -chroot_lock = "" -BIND_MOUNTS = ( - "/proc", - "/proc/sys/fs/binfmt_misc", - "/sys", - "/dev", - "/dev/pts", - "/dev/shm", - "/var/lib/dbus", - "/var/run/dbus", - "/var/lock", - ) - -def cleanup_after_chroot(targettype,imgmount,tmpdir,tmpmnt): - if imgmount and targettype == "img": - imgmount.cleanup() - - if tmpdir: - shutil.rmtree(tmpdir, ignore_errors = True) - - if tmpmnt: - shutil.rmtree(tmpmnt, ignore_errors = True) - -def check_bind_mounts(chrootdir, bindmounts): - chrootmounts = [] - for mount in bindmounts.split(";"): - if not mount: - continue - - srcdst = mount.split(":") - if len(srcdst) == 1: - srcdst.append("none") - - if not os.path.isdir(srcdst[0]): - return False - - if srcdst[1] == "" or srcdst[1] == "none": - srcdst[1] = None - - if srcdst[0] in BIND_MOUNTS or srcdst[0] == '/': - continue - - if chrootdir: - if not srcdst[1]: - srcdst[1] = os.path.abspath(os.path.expanduser(srcdst[0])) - else: - srcdst[1] = os.path.abspath(os.path.expanduser(srcdst[1])) - - tmpdir = chrootdir + "/" + srcdst[1] - if os.path.isdir(tmpdir): - msger.warning("Warning: dir %s has existed." % tmpdir) - - return True - -def cleanup_mounts(chrootdir): - umountcmd = misc.find_binary_path("umount") - abs_chrootdir = os.path.abspath(chrootdir) - mounts = open('/proc/mounts').readlines() - for line in reversed(mounts): - if abs_chrootdir not in line: - continue - - point = line.split()[1] - - # '/' to avoid common name prefix - if abs_chrootdir == point or point.startswith(abs_chrootdir + '/'): - args = [ umountcmd, "-l", point ] - ret = runner.quiet(args) - if ret != 0: - msger.warning("failed to unmount %s" % point) - - return 0 - -def setup_chrootenv(chrootdir, bindmounts = None, mountparent = True): - global chroot_lockfd, chroot_lock - - def get_bind_mounts(chrootdir, bindmounts, mountparent = True): - chrootmounts = [] - if bindmounts in ("", None): - bindmounts = "" - - for mount in bindmounts.split(";"): - if not mount: - continue - - srcdst = mount.split(":") - srcdst[0] = os.path.abspath(os.path.expanduser(srcdst[0])) - if len(srcdst) == 1: - srcdst.append("none") - - # if some bindmount is not existed, but it's created inside - # chroot, this is not expected - if not os.path.exists(srcdst[0]): - os.makedirs(srcdst[0]) - - if not os.path.isdir(srcdst[0]): - continue - - if srcdst[0] in BIND_MOUNTS or srcdst[0] == '/': - msger.verbose("%s will be mounted by default." % srcdst[0]) - continue - - if srcdst[1] == "" or srcdst[1] == "none": - srcdst[1] = None - else: - srcdst[1] = os.path.abspath(os.path.expanduser(srcdst[1])) - if os.path.isdir(chrootdir + "/" + srcdst[1]): - msger.warning("%s has existed in %s , skip it."\ - % (srcdst[1], chrootdir)) - continue - - chrootmounts.append(fs_related.BindChrootMount(srcdst[0], - chrootdir, - srcdst[1])) - - """Default bind mounts""" - for pt in BIND_MOUNTS: - if not os.path.exists(pt): - continue - chrootmounts.append(fs_related.BindChrootMount(pt, - chrootdir, - None)) - - if mountparent: - chrootmounts.append(fs_related.BindChrootMount("/", - chrootdir, - "/parentroot", - "ro")) - - for kernel in os.listdir("/lib/modules"): - chrootmounts.append(fs_related.BindChrootMount( - "/lib/modules/"+kernel, - chrootdir, - None, - "ro")) - - return chrootmounts - - def bind_mount(chrootmounts): - for b in chrootmounts: - msger.verbose("bind_mount: %s -> %s" % (b.src, b.dest)) - b.mount() - - def setup_resolv(chrootdir): - try: - shutil.copyfile("/etc/resolv.conf", chrootdir + "/etc/resolv.conf") - except: - pass - - globalmounts = get_bind_mounts(chrootdir, bindmounts, mountparent) - bind_mount(globalmounts) - - setup_resolv(chrootdir) - - mtab = "/etc/mtab" - dstmtab = chrootdir + mtab - if not os.path.islink(dstmtab): - shutil.copyfile(mtab, dstmtab) - - chroot_lock = os.path.join(chrootdir, ".chroot.lock") - chroot_lockfd = open(chroot_lock, "w") - - return globalmounts - -def cleanup_chrootenv(chrootdir, bindmounts=None, globalmounts=()): - global chroot_lockfd, chroot_lock - - def bind_unmount(chrootmounts): - for b in reversed(chrootmounts): - msger.verbose("bind_unmount: %s -> %s" % (b.src, b.dest)) - b.unmount() - - def cleanup_resolv(chrootdir): - try: - fd = open(chrootdir + "/etc/resolv.conf", "w") - fd.truncate(0) - fd.close() - except: - pass - - def kill_processes(chrootdir): - import glob - for fp in glob.glob("/proc/*/root"): - try: - if os.readlink(fp) == chrootdir: - pid = int(fp.split("/")[2]) - os.kill(pid, 9) - except: - pass - - def cleanup_mountdir(chrootdir, bindmounts): - if bindmounts == "" or bindmounts == None: - return - chrootmounts = [] - for mount in bindmounts.split(";"): - if not mount: - continue - - srcdst = mount.split(":") - - if len(srcdst) == 1: - srcdst.append("none") - - if srcdst[0] == "/": - continue - - if srcdst[1] == "" or srcdst[1] == "none": - srcdst[1] = srcdst[0] - - srcdst[1] = os.path.abspath(os.path.expanduser(srcdst[1])) - tmpdir = chrootdir + "/" + srcdst[1] - if os.path.isdir(tmpdir): - if len(os.listdir(tmpdir)) == 0: - shutil.rmtree(tmpdir, ignore_errors = True) - else: - msger.warning("Warning: dir %s isn't empty." % tmpdir) - - chroot_lockfd.close() - bind_unmount(globalmounts) - - if not fs_related.my_fuser(chroot_lock): - tmpdir = chrootdir + "/parentroot" - if os.path.exists(tmpdir) and len(os.listdir(tmpdir)) == 0: - shutil.rmtree(tmpdir, ignore_errors = True) - - cleanup_resolv(chrootdir) - - if os.path.exists(chrootdir + "/etc/mtab"): - os.unlink(chrootdir + "/etc/mtab") - - kill_processes(chrootdir) - - cleanup_mountdir(chrootdir, bindmounts) - -def chroot(chrootdir, bindmounts = None, execute = "/bin/bash"): - def mychroot(): - os.chroot(chrootdir) - os.chdir("/") - - if configmgr.chroot['saveto']: - savefs = True - saveto = configmgr.chroot['saveto'] - wrnmsg = "Can't save chroot fs for dir %s exists" % saveto - if saveto == chrootdir: - savefs = False - wrnmsg = "Dir %s is being used to chroot" % saveto - elif os.path.exists(saveto): - if msger.ask("Dir %s already exists, cleanup and continue?" % - saveto): - shutil.rmtree(saveto, ignore_errors = True) - savefs = True - else: - savefs = False - - if savefs: - msger.info("Saving image to directory %s" % saveto) - fs_related.makedirs(os.path.dirname(os.path.abspath(saveto))) - runner.quiet("cp -af %s %s" % (chrootdir, saveto)) - devs = ['dev/fd', - 'dev/stdin', - 'dev/stdout', - 'dev/stderr', - 'etc/mtab'] - ignlst = [os.path.join(saveto, x) for x in devs] - map(os.unlink, filter(os.path.exists, ignlst)) - else: - msger.warning(wrnmsg) - - dev_null = os.open("/dev/null", os.O_WRONLY) - files_to_check = ["/bin/bash", "/sbin/init"] - - architecture_found = False - - """ Register statically-linked qemu-arm if it is an ARM fs """ - qemu_emulator = None - - for ftc in files_to_check: - ftc = "%s/%s" % (chrootdir,ftc) - - # Return code of 'file' is "almost always" 0 based on some man pages - # so we need to check the file existance first. - if not os.path.exists(ftc): - continue - - for line in runner.outs(['file', ftc]).splitlines(): - if 'ARM' in line: - qemu_emulator = misc.setup_qemu_emulator(chrootdir, "arm") - architecture_found = True - break - - if 'Intel' in line: - architecture_found = True - break - - if architecture_found: - break - - os.close(dev_null) - if not architecture_found: - raise errors.CreatorError("Failed to get architecture from any of the " - "following files %s from chroot." \ - % files_to_check) - - try: - msger.info("Launching shell. Exit to continue.\n" - "----------------------------------") - globalmounts = setup_chrootenv(chrootdir, bindmounts) - subprocess.call(execute, preexec_fn = mychroot, shell=True) - - except OSError, err: - raise errors.CreatorError("chroot err: %s" % str(err)) - - finally: - cleanup_chrootenv(chrootdir, bindmounts, globalmounts) - if qemu_emulator: - os.unlink(chrootdir + qemu_emulator) diff --git a/scripts/lib/mic/conf.py b/scripts/lib/mic/conf.py deleted file mode 100644 index b850d80520..0000000000 --- a/scripts/lib/mic/conf.py +++ /dev/null @@ -1,197 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os, sys, re -import ConfigParser - -from mic import msger -from mic import kickstart -from mic.utils import misc, runner, proxy, errors - - -def get_siteconf(): - mic_path = os.path.dirname(__file__) - eos = mic_path.find('scripts') + len('scripts') - scripts_path = mic_path[:eos] - - return scripts_path + "/lib/image/config/wic.conf" - -class ConfigMgr(object): - prefer_backends = ["zypp", "yum"] - - DEFAULTS = {'common': { - "distro_name": "Default Distribution", - "plugin_dir": "/usr/lib/wic/plugins", # TODO use prefix also? - }, - 'create': { - "tmpdir": '/var/tmp/wic', - "cachedir": '/var/tmp/wic/cache', - "outdir": './wic-output', - - "arch": None, # None means auto-detect - "pkgmgr": "auto", - "name": "output", - "ksfile": None, - "ks": None, - "repomd": None, - "local_pkgs_path": None, - "release": None, - "logfile": None, - "record_pkgs": [], - "pack_to": None, - "name_prefix": None, - "name_suffix": None, - "proxy": None, - "no_proxy": None, - "copy_kernel": False, - "install_pkgs": None, - "repourl": {}, - "localrepos": [], # save localrepos - "runtime": "bootstrap", - }, - 'chroot': { - "saveto": None, - }, - 'convert': { - "shell": False, - }, - 'bootstrap': { - "rootdir": '/var/tmp/wic-bootstrap', - "packages": [], - }, - } - - # make the manager class as singleton - _instance = None - def __new__(cls, *args, **kwargs): - if not cls._instance: - cls._instance = super(ConfigMgr, cls).__new__(cls, *args, **kwargs) - - return cls._instance - - def __init__(self, ksconf=None, siteconf=None): - # reset config options - self.reset() - - if not siteconf: - siteconf = get_siteconf() - - # initial options from siteconf - self._siteconf = siteconf - - if ksconf: - self._ksconf = ksconf - - def reset(self): - self.__ksconf = None - self.__siteconf = None - - # initialize the values with defaults - for sec, vals in self.DEFAULTS.iteritems(): - setattr(self, sec, vals) - - def __set_siteconf(self, siteconf): - try: - self.__siteconf = siteconf - self._parse_siteconf(siteconf) - except ConfigParser.Error, error: - raise errors.ConfigError("%s" % error) - def __get_siteconf(self): - return self.__siteconf - _siteconf = property(__get_siteconf, __set_siteconf) - - def __set_ksconf(self, ksconf): - if not os.path.isfile(ksconf): - msger.error('Cannot find ks file: %s' % ksconf) - - self.__ksconf = ksconf - self._parse_kickstart(ksconf) - def __get_ksconf(self): - return self.__ksconf - _ksconf = property(__get_ksconf, __set_ksconf) - - def _parse_siteconf(self, siteconf): - if not siteconf: - return - - if not os.path.exists(siteconf): - msger.warning("cannot read config file: %s" % siteconf) - return - - parser = ConfigParser.SafeConfigParser() - parser.read(siteconf) - - for section in parser.sections(): - if section in self.DEFAULTS: - getattr(self, section).update(dict(parser.items(section))) - - # append common section items to other sections - for section in self.DEFAULTS.keys(): - if section != "common": - getattr(self, section).update(self.common) - - # check and normalize the scheme of proxy url - if self.create['proxy']: - m = re.match('^(\w+)://.*', self.create['proxy']) - if m: - scheme = m.group(1) - if scheme not in ('http', 'https', 'ftp', 'socks'): - msger.error("%s: proxy scheme is incorrect" % siteconf) - else: - msger.warning("%s: proxy url w/o scheme, use http as default" - % siteconf) - self.create['proxy'] = "http://" + self.create['proxy'] - - proxy.set_proxies(self.create['proxy'], self.create['no_proxy']) - - # bootstrap option handling - self.set_runtime(self.create['runtime']) - if isinstance(self.bootstrap['packages'], basestring): - packages = self.bootstrap['packages'].replace('\n', ' ') - if packages.find(',') != -1: - packages = packages.split(',') - else: - packages = packages.split() - self.bootstrap['packages'] = packages - - def _parse_kickstart(self, ksconf=None): - if not ksconf: - return - - ksconf = misc.normalize_ksfile(ksconf, - self.create['release'], - self.create['arch']) - - ks = kickstart.read_kickstart(ksconf) - - self.create['ks'] = ks - self.create['name'] = os.path.splitext(os.path.basename(ksconf))[0] - - self.create['name'] = misc.build_name(ksconf, - self.create['release'], - self.create['name_prefix'], - self.create['name_suffix']) - - def set_runtime(self, runtime): - if runtime not in ("bootstrap", "native"): - msger.error("Invalid runtime mode: %s" % runtime) - - if misc.get_distro()[0] in ("tizen", "Tizen"): - runtime = "native" - self.create['runtime'] = runtime - -configmgr = ConfigMgr() diff --git a/scripts/lib/mic/creator.py b/scripts/lib/mic/creator.py deleted file mode 100644 index 267928f877..0000000000 --- a/scripts/lib/mic/creator.py +++ /dev/null @@ -1,351 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os, sys, re -from optparse import SUPPRESS_HELP - -from mic import msger -from mic.utils import cmdln, errors -from mic.conf import configmgr -from mic.plugin import pluginmgr - - -class Creator(cmdln.Cmdln): - """${name}: create an image - - Usage: - ${name} SUBCOMMAND <ksfile> [OPTS] - - ${command_list} - ${option_list} - """ - - name = 'mic create(cr)' - - def __init__(self, *args, **kwargs): - cmdln.Cmdln.__init__(self, *args, **kwargs) - self._subcmds = [] - - # get cmds from pluginmgr - # mix-in do_subcmd interface - for subcmd, klass in pluginmgr.get_plugins('imager').iteritems(): - if not hasattr(klass, 'do_create'): - msger.warning("Unsurpport subcmd: %s" % subcmd) - continue - - func = getattr(klass, 'do_create') - setattr(self.__class__, "do_"+subcmd, func) - self._subcmds.append(subcmd) - - def get_optparser(self): - optparser = cmdln.CmdlnOptionParser(self) - optparser.add_option('-d', '--debug', action='store_true', - dest='debug', - help=SUPPRESS_HELP) - optparser.add_option('-v', '--verbose', action='store_true', - dest='verbose', - help=SUPPRESS_HELP) - optparser.add_option('', '--logfile', type='string', dest='logfile', - default=None, - help='Path of logfile') - optparser.add_option('-c', '--config', type='string', dest='config', - default=None, - help='Specify config file for mic') - optparser.add_option('-k', '--cachedir', type='string', action='store', - dest='cachedir', default=None, - help='Cache directory to store the downloaded') - optparser.add_option('-o', '--outdir', type='string', action='store', - dest='outdir', default=None, - help='Output directory') - optparser.add_option('-A', '--arch', type='string', dest='arch', - default=None, - help='Specify repo architecture') - optparser.add_option('', '--release', type='string', dest='release', - default=None, metavar='RID', - help='Generate a release of RID with all necessary' - ' files, when @BUILD_ID@ is contained in ' - 'kickstart file, it will be replaced by RID') - optparser.add_option("", "--record-pkgs", type="string", - dest="record_pkgs", default=None, - help='Record the info of installed packages, ' - 'multiple values can be specified which ' - 'joined by ",", valid values: "name", ' - '"content", "license", "vcs"') - optparser.add_option('', '--pkgmgr', type='string', dest='pkgmgr', - default=None, - help='Specify backend package manager') - optparser.add_option('', '--local-pkgs-path', type='string', - dest='local_pkgs_path', default=None, - help='Path for local pkgs(rpms) to be installed') - optparser.add_option('', '--runtime', type='string', - dest='runtime', default=None, - help='Specify runtime mode, avaiable: bootstrap, native') - # --taring-to is alias to --pack-to - optparser.add_option('', '--taring-to', type='string', - dest='pack_to', default=None, - help=SUPPRESS_HELP) - optparser.add_option('', '--pack-to', type='string', - dest='pack_to', default=None, - help='Pack the images together into the specified' - ' achive, extension supported: .zip, .tar, ' - '.tar.gz, .tar.bz2, etc. by default, .tar ' - 'will be used') - optparser.add_option('', '--copy-kernel', action='store_true', - dest='copy_kernel', - help='Copy kernel files from image /boot directory' - ' to the image output directory.') - optparser.add_option('', '--install-pkgs', type='string', action='store', - dest='install_pkgs', default=None, - help='Specify what type of packages to be installed,' - ' valid: source, debuginfo, debugsource') - optparser.add_option('', '--tmpfs', action='store_true', dest='enabletmpfs', - help='Setup tmpdir as tmpfs to accelerate, experimental' - ' feature, use it if you have more than 4G memory') - optparser.add_option('', '--repourl', action='append', - dest='repourl', default=[], - help=SUPPRESS_HELP) - return optparser - - def preoptparse(self, argv): - optparser = self.get_optparser() - - largs = [] - rargs = [] - while argv: - arg = argv.pop(0) - - if arg in ('-h', '--help'): - rargs.append(arg) - - elif optparser.has_option(arg): - largs.append(arg) - - if optparser.get_option(arg).takes_value(): - try: - largs.append(argv.pop(0)) - except IndexError: - raise errors.Usage("option %s requires arguments" % arg) - - else: - if arg.startswith("--"): - if "=" in arg: - opt = arg.split("=")[0] - else: - opt = None - elif arg.startswith("-") and len(arg) > 2: - opt = arg[0:2] - else: - opt = None - - if opt and optparser.has_option(opt): - largs.append(arg) - else: - rargs.append(arg) - - return largs + rargs - - def postoptparse(self): - abspath = lambda pth: os.path.abspath(os.path.expanduser(pth)) - - if self.options.verbose: - msger.set_loglevel('verbose') - if self.options.debug: - msger.set_loglevel('debug') - - if self.options.logfile: - logfile_abs_path = abspath(self.options.logfile) - if os.path.isdir(logfile_abs_path): - raise errors.Usage("logfile's path %s should be file" - % self.options.logfile) - if not os.path.exists(os.path.dirname(logfile_abs_path)): - os.makedirs(os.path.dirname(logfile_abs_path)) - msger.set_interactive(False) - msger.set_logfile(logfile_abs_path) - configmgr.create['logfile'] = self.options.logfile - - if self.options.config: - configmgr.reset() - configmgr._siteconf = self.options.config - - if self.options.outdir is not None: - configmgr.create['outdir'] = abspath(self.options.outdir) - if self.options.cachedir is not None: - configmgr.create['cachedir'] = abspath(self.options.cachedir) - os.environ['ZYPP_LOCKFILE_ROOT'] = configmgr.create['cachedir'] - - for cdir in ('outdir', 'cachedir'): - if os.path.exists(configmgr.create[cdir]) \ - and not os.path.isdir(configmgr.create[cdir]): - msger.error('Invalid directory specified: %s' \ - % configmgr.create[cdir]) - - if self.options.local_pkgs_path is not None: - if not os.path.exists(self.options.local_pkgs_path): - msger.error('Local pkgs directory: \'%s\' not exist' \ - % self.options.local_pkgs_path) - configmgr.create['local_pkgs_path'] = self.options.local_pkgs_path - - if self.options.release: - configmgr.create['release'] = self.options.release.rstrip('/') - - if self.options.record_pkgs: - configmgr.create['record_pkgs'] = [] - for infotype in self.options.record_pkgs.split(','): - if infotype not in ('name', 'content', 'license', 'vcs'): - raise errors.Usage('Invalid pkg recording: %s, valid ones:' - ' "name", "content", "license", "vcs"' \ - % infotype) - - configmgr.create['record_pkgs'].append(infotype) - - if self.options.arch is not None: - supported_arch = sorted(rpmmisc.archPolicies.keys(), reverse=True) - if self.options.arch in supported_arch: - configmgr.create['arch'] = self.options.arch - else: - raise errors.Usage('Invalid architecture: "%s".\n' - ' Supported architectures are: \n' - ' %s' % (self.options.arch, - ', '.join(supported_arch))) - - if self.options.pkgmgr is not None: - configmgr.create['pkgmgr'] = self.options.pkgmgr - - if self.options.runtime: - configmgr.set_runtime(self.options.runtime) - - if self.options.pack_to is not None: - configmgr.create['pack_to'] = self.options.pack_to - - if self.options.copy_kernel: - configmgr.create['copy_kernel'] = self.options.copy_kernel - - if self.options.install_pkgs: - configmgr.create['install_pkgs'] = [] - for pkgtype in self.options.install_pkgs.split(','): - if pkgtype not in ('source', 'debuginfo', 'debugsource'): - raise errors.Usage('Invalid parameter specified: "%s", ' - 'valid values: source, debuginfo, ' - 'debusource' % pkgtype) - - configmgr.create['install_pkgs'].append(pkgtype) - - if self.options.enabletmpfs: - configmgr.create['enabletmpfs'] = self.options.enabletmpfs - - if self.options.repourl: - for item in self.options.repourl: - try: - key, val = item.split('=') - except: - continue - configmgr.create['repourl'][key] = val - - def main(self, argv=None): - if argv is None: - argv = sys.argv - else: - argv = argv[:] # don't modify caller's list - - self.optparser = self.get_optparser() - if self.optparser: - try: - argv = self.preoptparse(argv) - self.options, args = self.optparser.parse_args(argv) - - except cmdln.CmdlnUserError, ex: - msg = "%s: %s\nTry '%s help' for info.\n"\ - % (self.name, ex, self.name) - msger.error(msg) - - except cmdln.StopOptionProcessing, ex: - return 0 - else: - # optparser=None means no process for opts - self.options, args = None, argv[1:] - - if not args: - return self.emptyline() - - self.postoptparse() - - return self.cmd(args) - - def precmd(self, argv): # check help before cmd - - if '-h' in argv or '?' in argv or '--help' in argv or 'help' in argv: - return argv - - if len(argv) == 1: - return ['help', argv[0]] - - return argv - - def do_auto(self, subcmd, opts, *args): - """${cmd_name}: auto detect image type from magic header - - Usage: - ${name} ${cmd_name} <ksfile> - - ${cmd_option_list} - """ - def parse_magic_line(re_str, pstr, ptype='mic'): - ptn = re.compile(re_str) - m = ptn.match(pstr) - if not m or not m.groups(): - return None - - inline_argv = m.group(1).strip() - if ptype == 'mic': - m2 = re.search('(?P<format>\w+)', inline_argv) - elif ptype == 'mic2': - m2 = re.search('(-f|--format(=)?)\s*(?P<format>\w+)', - inline_argv) - else: - return None - - if m2: - cmdname = m2.group('format') - inline_argv = inline_argv.replace(m2.group(0), '') - return (cmdname, inline_argv) - - return None - - if len(args) != 1: - raise errors.Usage("Extra arguments given") - - if not os.path.exists(args[0]): - raise errors.CreatorError("Can't find the file: %s" % args[0]) - - with open(args[0], 'r') as rf: - first_line = rf.readline() - - mic_re = '^#\s*-\*-mic-options-\*-\s+(.*)\s+-\*-mic-options-\*-' - mic2_re = '^#\s*-\*-mic2-options-\*-\s+(.*)\s+-\*-mic2-options-\*-' - - result = parse_magic_line(mic_re, first_line, 'mic') \ - or parse_magic_line(mic2_re, first_line, 'mic2') - if not result: - raise errors.KsError("Invalid magic line in file: %s" % args[0]) - - if result[0] not in self._subcmds: - raise errors.KsError("Unsupport format '%s' in %s" - % (result[0], args[0])) - - argv = ' '.join(result + args).split() - self.main(argv) - diff --git a/scripts/lib/mic/imager/baseimager.py b/scripts/lib/mic/imager/baseimager.py deleted file mode 100644 index b7212493b4..0000000000 --- a/scripts/lib/mic/imager/baseimager.py +++ /dev/null @@ -1,1263 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2007 Red Hat Inc. -# Copyright (c) 2009, 2010, 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -from __future__ import with_statement -import os, sys -import stat -import tempfile -import shutil -import subprocess -import re -import tarfile -import glob - -from mic import kickstart -from mic import msger -from mic.utils.errors import CreatorError, Abort -from mic.utils import misc, runner, fs_related as fs - -class BaseImageCreator(object): - """Installs a system to a chroot directory. - - ImageCreator is the simplest creator class available; it will install and - configure a system image according to the supplied kickstart file. - - e.g. - - import mic.imgcreate as imgcreate - ks = imgcreate.read_kickstart("foo.ks") - imgcreate.ImageCreator(ks, "foo").create() - - """ - - def __del__(self): - self.cleanup() - - def __init__(self, createopts = None, pkgmgr = None): - """Initialize an ImageCreator instance. - - ks -- a pykickstart.KickstartParser instance; this instance will be - used to drive the install by e.g. providing the list of packages - to be installed, the system configuration and %post scripts - - name -- a name for the image; used for e.g. image filenames or - filesystem labels - """ - - self.pkgmgr = pkgmgr - - self.__builddir = None - self.__bindmounts = [] - - self.ks = None - self.name = "target" - self.tmpdir = "/var/tmp/wic" - self.cachedir = "/var/tmp/wic/cache" - self.workdir = "/var/tmp/wic/build" - - self.destdir = "." - self.installerfw_prefix = "INSTALLERFW_" - self.target_arch = "noarch" - self._local_pkgs_path = None - self.pack_to = None - self.repourl = {} - - # If the kernel is save to the destdir when copy_kernel cmd is called. - self._need_copy_kernel = False - # setup tmpfs tmpdir when enabletmpfs is True - self.enabletmpfs = False - - if createopts: - # Mapping table for variables that have different names. - optmap = {"pkgmgr" : "pkgmgr_name", - "outdir" : "destdir", - "arch" : "target_arch", - "local_pkgs_path" : "_local_pkgs_path", - "copy_kernel" : "_need_copy_kernel", - } - - # update setting from createopts - for key in createopts.keys(): - if key in optmap: - option = optmap[key] - else: - option = key - setattr(self, option, createopts[key]) - - self.destdir = os.path.abspath(os.path.expanduser(self.destdir)) - - if 'release' in createopts and createopts['release']: - self.name = createopts['release'] + '_' + self.name - - if self.pack_to: - if '@NAME@' in self.pack_to: - self.pack_to = self.pack_to.replace('@NAME@', self.name) - (tar, ext) = os.path.splitext(self.pack_to) - if ext in (".gz", ".bz2") and tar.endswith(".tar"): - ext = ".tar" + ext - if ext not in misc.pack_formats: - self.pack_to += ".tar" - - self._dep_checks = ["ls", "bash", "cp", "echo", "modprobe"] - - # Output image file names - self.outimage = [] - - # A flag to generate checksum - self._genchecksum = False - - self._alt_initrd_name = None - - self._recording_pkgs = [] - - # available size in root fs, init to 0 - self._root_fs_avail = 0 - - # Name of the disk image file that is created. - self._img_name = None - - self.image_format = None - - # Save qemu emulator file name in order to clean up it finally - self.qemu_emulator = None - - # No ks provided when called by convertor, so skip the dependency check - if self.ks: - # If we have btrfs partition we need to check necessary tools - for part in self.ks.handler.partition.partitions: - if part.fstype and part.fstype == "btrfs": - self._dep_checks.append("mkfs.btrfs") - break - - if self.target_arch and self.target_arch.startswith("arm"): - for dep in self._dep_checks: - if dep == "extlinux": - self._dep_checks.remove(dep) - - if not os.path.exists("/usr/bin/qemu-arm") or \ - not misc.is_statically_linked("/usr/bin/qemu-arm"): - self._dep_checks.append("qemu-arm-static") - - if os.path.exists("/proc/sys/vm/vdso_enabled"): - vdso_fh = open("/proc/sys/vm/vdso_enabled","r") - vdso_value = vdso_fh.read().strip() - vdso_fh.close() - if (int)(vdso_value) == 1: - msger.warning("vdso is enabled on your host, which might " - "cause problems with arm emulations.\n" - "\tYou can disable vdso with following command before " - "starting image build:\n" - "\techo 0 | sudo tee /proc/sys/vm/vdso_enabled") - - # make sure the specified tmpdir and cachedir exist - if not os.path.exists(self.tmpdir): - os.makedirs(self.tmpdir) - if not os.path.exists(self.cachedir): - os.makedirs(self.cachedir) - - - # - # Properties - # - def __get_instroot(self): - if self.__builddir is None: - raise CreatorError("_instroot is not valid before calling mount()") - return self.__builddir + "/install_root" - _instroot = property(__get_instroot) - """The location of the install root directory. - - This is the directory into which the system is installed. Subclasses may - mount a filesystem image here or copy files to/from here. - - Note, this directory does not exist before ImageCreator.mount() is called. - - Note also, this is a read-only attribute. - - """ - - def __get_outdir(self): - if self.__builddir is None: - raise CreatorError("_outdir is not valid before calling mount()") - return self.__builddir + "/out" - _outdir = property(__get_outdir) - """The staging location for the final image. - - This is where subclasses should stage any files that are part of the final - image. ImageCreator.package() will copy any files found here into the - requested destination directory. - - Note, this directory does not exist before ImageCreator.mount() is called. - - Note also, this is a read-only attribute. - - """ - - - # - # Hooks for subclasses - # - def _mount_instroot(self, base_on = None): - """Mount or prepare the install root directory. - - This is the hook where subclasses may prepare the install root by e.g. - mounting creating and loopback mounting a filesystem image to - _instroot. - - There is no default implementation. - - base_on -- this is the value passed to mount() and can be interpreted - as the subclass wishes; it might e.g. be the location of - a previously created ISO containing a system image. - - """ - pass - - def _unmount_instroot(self): - """Undo anything performed in _mount_instroot(). - - This is the hook where subclasses must undo anything which was done - in _mount_instroot(). For example, if a filesystem image was mounted - onto _instroot, it should be unmounted here. - - There is no default implementation. - - """ - pass - - def _create_bootconfig(self): - """Configure the image so that it's bootable. - - This is the hook where subclasses may prepare the image for booting by - e.g. creating an initramfs and bootloader configuration. - - This hook is called while the install root is still mounted, after the - packages have been installed and the kickstart configuration has been - applied, but before the %post scripts have been executed. - - There is no default implementation. - - """ - pass - - def _stage_final_image(self): - """Stage the final system image in _outdir. - - This is the hook where subclasses should place the image in _outdir - so that package() can copy it to the requested destination directory. - - By default, this moves the install root into _outdir. - - """ - shutil.move(self._instroot, self._outdir + "/" + self.name) - - def get_installed_packages(self): - return self._pkgs_content.keys() - - def _save_recording_pkgs(self, destdir): - """Save the list or content of installed packages to file. - """ - pkgs = self._pkgs_content.keys() - pkgs.sort() # inplace op - - if not os.path.exists(destdir): - os.makedirs(destdir) - - content = None - if 'vcs' in self._recording_pkgs: - vcslst = ["%s %s" % (k, v) for (k, v) in self._pkgs_vcsinfo.items()] - content = '\n'.join(sorted(vcslst)) - elif 'name' in self._recording_pkgs: - content = '\n'.join(pkgs) - if content: - namefile = os.path.join(destdir, self.name + '.packages') - f = open(namefile, "w") - f.write(content) - f.close() - self.outimage.append(namefile); - - # if 'content', save more details - if 'content' in self._recording_pkgs: - contfile = os.path.join(destdir, self.name + '.files') - f = open(contfile, "w") - - for pkg in pkgs: - content = pkg + '\n' - - pkgcont = self._pkgs_content[pkg] - content += ' ' - content += '\n '.join(pkgcont) - content += '\n' - - content += '\n' - f.write(content) - f.close() - self.outimage.append(contfile) - - if 'license' in self._recording_pkgs: - licensefile = os.path.join(destdir, self.name + '.license') - f = open(licensefile, "w") - - f.write('Summary:\n') - for license in reversed(sorted(self._pkgs_license, key=\ - lambda license: len(self._pkgs_license[license]))): - f.write(" - %s: %s\n" \ - % (license, len(self._pkgs_license[license]))) - - f.write('\nDetails:\n') - for license in reversed(sorted(self._pkgs_license, key=\ - lambda license: len(self._pkgs_license[license]))): - f.write(" - %s:\n" % (license)) - for pkg in sorted(self._pkgs_license[license]): - f.write(" - %s\n" % (pkg)) - f.write('\n') - - f.close() - self.outimage.append(licensefile) - - def _get_required_packages(self): - """Return a list of required packages. - - This is the hook where subclasses may specify a set of packages which - it requires to be installed. - - This returns an empty list by default. - - Note, subclasses should usually chain up to the base class - implementation of this hook. - - """ - return [] - - def _get_excluded_packages(self): - """Return a list of excluded packages. - - This is the hook where subclasses may specify a set of packages which - it requires _not_ to be installed. - - This returns an empty list by default. - - Note, subclasses should usually chain up to the base class - implementation of this hook. - - """ - return [] - - def _get_local_packages(self): - """Return a list of rpm path to be local installed. - - This is the hook where subclasses may specify a set of rpms which - it requires to be installed locally. - - This returns an empty list by default. - - Note, subclasses should usually chain up to the base class - implementation of this hook. - - """ - if self._local_pkgs_path: - if os.path.isdir(self._local_pkgs_path): - return glob.glob( - os.path.join(self._local_pkgs_path, '*.rpm')) - elif os.path.splitext(self._local_pkgs_path)[-1] == '.rpm': - return [self._local_pkgs_path] - - return [] - - def _get_fstab(self): - """Return the desired contents of /etc/fstab. - - This is the hook where subclasses may specify the contents of - /etc/fstab by returning a string containing the desired contents. - - A sensible default implementation is provided. - - """ - s = "/dev/root / %s %s 0 0\n" \ - % (self._fstype, - "defaults,noatime" if not self._fsopts else self._fsopts) - s += self._get_fstab_special() - return s - - def _get_fstab_special(self): - s = "devpts /dev/pts devpts gid=5,mode=620 0 0\n" - s += "tmpfs /dev/shm tmpfs defaults 0 0\n" - s += "proc /proc proc defaults 0 0\n" - s += "sysfs /sys sysfs defaults 0 0\n" - return s - - def _set_part_env(self, pnum, prop, value): - """ This is a helper function which generates an environment variable - for a property "prop" with value "value" of a partition number "pnum". - - The naming convention is: - * Variables start with INSTALLERFW_PART - * Then goes the partition number, the order is the same as - specified in the KS file - * Then goes the property name - """ - - if value == None: - value = "" - else: - value = str(value) - - name = self.installerfw_prefix + ("PART%d_" % pnum) + prop - return { name : value } - - def _get_post_scripts_env(self, in_chroot): - """Return an environment dict for %post scripts. - - This is the hook where subclasses may specify some environment - variables for %post scripts by return a dict containing the desired - environment. - - in_chroot -- whether this %post script is to be executed chroot()ed - into _instroot. - """ - - env = {} - pnum = 0 - - for p in kickstart.get_partitions(self.ks): - env.update(self._set_part_env(pnum, "SIZE", p.size)) - env.update(self._set_part_env(pnum, "MOUNTPOINT", p.mountpoint)) - env.update(self._set_part_env(pnum, "FSTYPE", p.fstype)) - env.update(self._set_part_env(pnum, "LABEL", p.label)) - env.update(self._set_part_env(pnum, "FSOPTS", p.fsopts)) - env.update(self._set_part_env(pnum, "BOOTFLAG", p.active)) - env.update(self._set_part_env(pnum, "ALIGN", p.align)) - env.update(self._set_part_env(pnum, "TYPE_ID", p.part_type)) - env.update(self._set_part_env(pnum, "DEVNODE", - "/dev/%s%d" % (p.disk, pnum + 1))) - pnum += 1 - - # Count of paritions - env[self.installerfw_prefix + "PART_COUNT"] = str(pnum) - - # Partition table format - ptable_format = self.ks.handler.bootloader.ptable - env[self.installerfw_prefix + "PTABLE_FORMAT"] = ptable_format - - # The kerned boot parameters - kernel_opts = self.ks.handler.bootloader.appendLine - env[self.installerfw_prefix + "KERNEL_OPTS"] = kernel_opts - - # Name of the distribution - env[self.installerfw_prefix + "DISTRO_NAME"] = self.distro_name - - # Name of the image creation tool - env[self.installerfw_prefix + "INSTALLER_NAME"] = "wic" - - # The real current location of the mounted file-systems - if in_chroot: - mount_prefix = "/" - else: - mount_prefix = self._instroot - env[self.installerfw_prefix + "MOUNT_PREFIX"] = mount_prefix - - # These are historical variables which lack the common name prefix - if not in_chroot: - env["INSTALL_ROOT"] = self._instroot - env["IMG_NAME"] = self._name - - return env - - def __get_imgname(self): - return self.name - _name = property(__get_imgname) - """The name of the image file. - - """ - - def _get_kernel_versions(self): - """Return a dict detailing the available kernel types/versions. - - This is the hook where subclasses may override what kernel types and - versions should be available for e.g. creating the booloader - configuration. - - A dict should be returned mapping the available kernel types to a list - of the available versions for those kernels. - - The default implementation uses rpm to iterate over everything - providing 'kernel', finds /boot/vmlinuz-* and returns the version - obtained from the vmlinuz filename. (This can differ from the kernel - RPM's n-v-r in the case of e.g. xen) - - """ - def get_kernel_versions(instroot): - ret = {} - versions = set() - files = glob.glob(instroot + "/boot/vmlinuz-*") - for file in files: - version = os.path.basename(file)[8:] - if version is None: - continue - versions.add(version) - ret["kernel"] = list(versions) - return ret - - def get_version(header): - version = None - for f in header['filenames']: - if f.startswith('/boot/vmlinuz-'): - version = f[14:] - return version - - if self.ks is None: - return get_kernel_versions(self._instroot) - - ts = rpm.TransactionSet(self._instroot) - - ret = {} - for header in ts.dbMatch('provides', 'kernel'): - version = get_version(header) - if version is None: - continue - - name = header['name'] - if not name in ret: - ret[name] = [version] - elif not version in ret[name]: - ret[name].append(version) - - return ret - - - # - # Helpers for subclasses - # - def _do_bindmounts(self): - """Mount various system directories onto _instroot. - - This method is called by mount(), but may also be used by subclasses - in order to re-mount the bindmounts after modifying the underlying - filesystem. - - """ - for b in self.__bindmounts: - b.mount() - - def _undo_bindmounts(self): - """Unmount the bind-mounted system directories from _instroot. - - This method is usually only called by unmount(), but may also be used - by subclasses in order to gain access to the filesystem obscured by - the bindmounts - e.g. in order to create device nodes on the image - filesystem. - - """ - self.__bindmounts.reverse() - for b in self.__bindmounts: - b.unmount() - - def _chroot(self): - """Chroot into the install root. - - This method may be used by subclasses when executing programs inside - the install root e.g. - - subprocess.call(["/bin/ls"], preexec_fn = self.chroot) - - """ - os.chroot(self._instroot) - os.chdir("/") - - def _mkdtemp(self, prefix = "tmp-"): - """Create a temporary directory. - - This method may be used by subclasses to create a temporary directory - for use in building the final image - e.g. a subclass might create - a temporary directory in order to bundle a set of files into a package. - - The subclass may delete this directory if it wishes, but it will be - automatically deleted by cleanup(). - - The absolute path to the temporary directory is returned. - - Note, this method should only be called after mount() has been called. - - prefix -- a prefix which should be used when creating the directory; - defaults to "tmp-". - - """ - self.__ensure_builddir() - return tempfile.mkdtemp(dir = self.__builddir, prefix = prefix) - - def _mkstemp(self, prefix = "tmp-"): - """Create a temporary file. - - This method may be used by subclasses to create a temporary file - for use in building the final image - e.g. a subclass might need - a temporary location to unpack a compressed file. - - The subclass may delete this file if it wishes, but it will be - automatically deleted by cleanup(). - - A tuple containing a file descriptor (returned from os.open() and the - absolute path to the temporary directory is returned. - - Note, this method should only be called after mount() has been called. - - prefix -- a prefix which should be used when creating the file; - defaults to "tmp-". - - """ - self.__ensure_builddir() - return tempfile.mkstemp(dir = self.__builddir, prefix = prefix) - - def _mktemp(self, prefix = "tmp-"): - """Create a temporary file. - - This method simply calls _mkstemp() and closes the returned file - descriptor. - - The absolute path to the temporary file is returned. - - Note, this method should only be called after mount() has been called. - - prefix -- a prefix which should be used when creating the file; - defaults to "tmp-". - - """ - - (f, path) = self._mkstemp(prefix) - os.close(f) - return path - - - # - # Actual implementation - # - def __ensure_builddir(self): - if not self.__builddir is None: - return - - try: - self.workdir = os.path.join(self.tmpdir, "build") - if not os.path.exists(self.workdir): - os.makedirs(self.workdir) - self.__builddir = tempfile.mkdtemp(dir = self.workdir, - prefix = "imgcreate-") - except OSError, (err, msg): - raise CreatorError("Failed create build directory in %s: %s" % - (self.tmpdir, msg)) - - def get_cachedir(self, cachedir = None): - if self.cachedir: - return self.cachedir - - self.__ensure_builddir() - if cachedir: - self.cachedir = cachedir - else: - self.cachedir = self.__builddir + "/wic-cache" - fs.makedirs(self.cachedir) - return self.cachedir - - def __sanity_check(self): - """Ensure that the config we've been given is sane.""" - if not (kickstart.get_packages(self.ks) or - kickstart.get_groups(self.ks)): - raise CreatorError("No packages or groups specified") - - kickstart.convert_method_to_repo(self.ks) - - if not kickstart.get_repos(self.ks): - raise CreatorError("No repositories specified") - - def __write_fstab(self): - fstab_contents = self._get_fstab() - if fstab_contents: - fstab = open(self._instroot + "/etc/fstab", "w") - fstab.write(fstab_contents) - fstab.close() - - def __create_minimal_dev(self): - """Create a minimal /dev so that we don't corrupt the host /dev""" - origumask = os.umask(0000) - devices = (('null', 1, 3, 0666), - ('urandom',1, 9, 0666), - ('random', 1, 8, 0666), - ('full', 1, 7, 0666), - ('ptmx', 5, 2, 0666), - ('tty', 5, 0, 0666), - ('zero', 1, 5, 0666)) - - links = (("/proc/self/fd", "/dev/fd"), - ("/proc/self/fd/0", "/dev/stdin"), - ("/proc/self/fd/1", "/dev/stdout"), - ("/proc/self/fd/2", "/dev/stderr")) - - for (node, major, minor, perm) in devices: - if not os.path.exists(self._instroot + "/dev/" + node): - os.mknod(self._instroot + "/dev/" + node, - perm | stat.S_IFCHR, - os.makedev(major,minor)) - - for (src, dest) in links: - if not os.path.exists(self._instroot + dest): - os.symlink(src, self._instroot + dest) - - os.umask(origumask) - - def __setup_tmpdir(self): - if not self.enabletmpfs: - return - - runner.show('mount -t tmpfs -o size=4G tmpfs %s' % self.workdir) - - def __clean_tmpdir(self): - if not self.enabletmpfs: - return - - runner.show('umount -l %s' % self.workdir) - - def mount(self, base_on = None, cachedir = None): - """Setup the target filesystem in preparation for an install. - - This function sets up the filesystem which the ImageCreator will - install into and configure. The ImageCreator class merely creates an - install root directory, bind mounts some system directories (e.g. /dev) - and writes out /etc/fstab. Other subclasses may also e.g. create a - sparse file, format it and loopback mount it to the install root. - - base_on -- a previous install on which to base this install; defaults - to None, causing a new image to be created - - cachedir -- a directory in which to store the Yum cache; defaults to - None, causing a new cache to be created; by setting this - to another directory, the same cache can be reused across - multiple installs. - - """ - self.__setup_tmpdir() - self.__ensure_builddir() - - self._mount_instroot(base_on) - - def unmount(self): - """Unmounts the target filesystem. - - The ImageCreator class detaches the system from the install root, but - other subclasses may also detach the loopback mounted filesystem image - from the install root. - - """ - self._unmount_instroot() - - - def cleanup(self): - """Unmounts the target filesystem and deletes temporary files. - - This method calls unmount() and then deletes any temporary files and - directories that were created on the host system while building the - image. - - Note, make sure to call this method once finished with the creator - instance in order to ensure no stale files are left on the host e.g.: - - creator = ImageCreator(ks, name) - try: - creator.create() - finally: - creator.cleanup() - - """ - if not self.__builddir: - return - - self.unmount() - - shutil.rmtree(self.__builddir, ignore_errors = True) - self.__builddir = None - - self.__clean_tmpdir() - - def __is_excluded_pkg(self, pkg): - if pkg in self._excluded_pkgs: - self._excluded_pkgs.remove(pkg) - return True - - for xpkg in self._excluded_pkgs: - if xpkg.endswith('*'): - if pkg.startswith(xpkg[:-1]): - return True - elif xpkg.startswith('*'): - if pkg.endswith(xpkg[1:]): - return True - - return None - - def __select_packages(self, pkg_manager): - skipped_pkgs = [] - for pkg in self._required_pkgs: - e = pkg_manager.selectPackage(pkg) - if e: - if kickstart.ignore_missing(self.ks): - skipped_pkgs.append(pkg) - elif self.__is_excluded_pkg(pkg): - skipped_pkgs.append(pkg) - else: - raise CreatorError("Failed to find package '%s' : %s" % - (pkg, e)) - - for pkg in skipped_pkgs: - msger.warning("Skipping missing package '%s'" % (pkg,)) - - def __select_groups(self, pkg_manager): - skipped_groups = [] - for group in self._required_groups: - e = pkg_manager.selectGroup(group.name, group.include) - if e: - if kickstart.ignore_missing(self.ks): - skipped_groups.append(group) - else: - raise CreatorError("Failed to find group '%s' : %s" % - (group.name, e)) - - for group in skipped_groups: - msger.warning("Skipping missing group '%s'" % (group.name,)) - - def __deselect_packages(self, pkg_manager): - for pkg in self._excluded_pkgs: - pkg_manager.deselectPackage(pkg) - - def __localinst_packages(self, pkg_manager): - for rpm_path in self._get_local_packages(): - pkg_manager.installLocal(rpm_path) - - def __preinstall_packages(self, pkg_manager): - if not self.ks: - return - - self._preinstall_pkgs = kickstart.get_pre_packages(self.ks) - for pkg in self._preinstall_pkgs: - pkg_manager.preInstall(pkg) - - def __attachment_packages(self, pkg_manager): - if not self.ks: - return - - self._attachment = [] - for item in kickstart.get_attachment(self.ks): - if item.startswith('/'): - fpaths = os.path.join(self._instroot, item.lstrip('/')) - for fpath in glob.glob(fpaths): - self._attachment.append(fpath) - continue - - filelist = pkg_manager.getFilelist(item) - if filelist: - # found rpm in rootfs - for pfile in pkg_manager.getFilelist(item): - fpath = os.path.join(self._instroot, pfile.lstrip('/')) - self._attachment.append(fpath) - continue - - # try to retrieve rpm file - (url, proxies) = pkg_manager.package_url(item) - if not url: - msger.warning("Can't get url from repo for %s" % item) - continue - fpath = os.path.join(self.cachedir, os.path.basename(url)) - if not os.path.exists(fpath): - # download pkgs - try: - fpath = grabber.myurlgrab(url, fpath, proxies, None) - except CreatorError: - raise - - tmpdir = self._mkdtemp() - misc.extract_rpm(fpath, tmpdir) - for (root, dirs, files) in os.walk(tmpdir): - for fname in files: - fpath = os.path.join(root, fname) - self._attachment.append(fpath) - - def install(self, repo_urls=None): - """Install packages into the install root. - - This function installs the packages listed in the supplied kickstart - into the install root. By default, the packages are installed from the - repository URLs specified in the kickstart. - - repo_urls -- a dict which maps a repository name to a repository URL; - if supplied, this causes any repository URLs specified in - the kickstart to be overridden. - - """ - - # initialize pkg list to install - if self.ks: - self.__sanity_check() - - self._required_pkgs = \ - kickstart.get_packages(self.ks, self._get_required_packages()) - self._excluded_pkgs = \ - kickstart.get_excluded(self.ks, self._get_excluded_packages()) - self._required_groups = kickstart.get_groups(self.ks) - else: - self._required_pkgs = None - self._excluded_pkgs = None - self._required_groups = None - - pkg_manager = self.get_pkg_manager() - pkg_manager.setup() - - if hasattr(self, 'install_pkgs') and self.install_pkgs: - if 'debuginfo' in self.install_pkgs: - pkg_manager.install_debuginfo = True - - for repo in kickstart.get_repos(self.ks, repo_urls): - (name, baseurl, mirrorlist, inc, exc, - proxy, proxy_username, proxy_password, debuginfo, - source, gpgkey, disable, ssl_verify, nocache, - cost, priority) = repo - - yr = pkg_manager.addRepository(name, baseurl, mirrorlist, proxy, - proxy_username, proxy_password, inc, exc, ssl_verify, - nocache, cost, priority) - - if kickstart.exclude_docs(self.ks): - rpm.addMacro("_excludedocs", "1") - rpm.addMacro("_dbpath", "/var/lib/rpm") - rpm.addMacro("__file_context_path", "%{nil}") - if kickstart.inst_langs(self.ks) != None: - rpm.addMacro("_install_langs", kickstart.inst_langs(self.ks)) - - try: - self.__preinstall_packages(pkg_manager) - self.__select_packages(pkg_manager) - self.__select_groups(pkg_manager) - self.__deselect_packages(pkg_manager) - self.__localinst_packages(pkg_manager) - - BOOT_SAFEGUARD = 256L * 1024 * 1024 # 256M - checksize = self._root_fs_avail - if checksize: - checksize -= BOOT_SAFEGUARD - if self.target_arch: - pkg_manager._add_prob_flags(rpm.RPMPROB_FILTER_IGNOREARCH) - pkg_manager.runInstall(checksize) - except CreatorError, e: - raise - except KeyboardInterrupt: - raise - else: - self._pkgs_content = pkg_manager.getAllContent() - self._pkgs_license = pkg_manager.getPkgsLicense() - self._pkgs_vcsinfo = pkg_manager.getVcsInfo() - self.__attachment_packages(pkg_manager) - finally: - pkg_manager.close() - - # hook post install - self.postinstall() - - # do some clean up to avoid lvm info leakage. this sucks. - for subdir in ("cache", "backup", "archive"): - lvmdir = self._instroot + "/etc/lvm/" + subdir - try: - for f in os.listdir(lvmdir): - os.unlink(lvmdir + "/" + f) - except: - pass - - def postinstall(self): - self.copy_attachment() - - def __run_post_scripts(self): - msger.info("Running scripts ...") - if os.path.exists(self._instroot + "/tmp"): - shutil.rmtree(self._instroot + "/tmp") - os.mkdir (self._instroot + "/tmp", 0755) - for s in kickstart.get_post_scripts(self.ks): - (fd, path) = tempfile.mkstemp(prefix = "ks-script-", - dir = self._instroot + "/tmp") - - s.script = s.script.replace("\r", "") - os.write(fd, s.script) - os.close(fd) - os.chmod(path, 0700) - - env = self._get_post_scripts_env(s.inChroot) - - if not s.inChroot: - preexec = None - script = path - else: - preexec = self._chroot - script = "/tmp/" + os.path.basename(path) - - try: - try: - subprocess.call([s.interp, script], - preexec_fn = preexec, - env = env, - stdout = sys.stdout, - stderr = sys.stderr) - except OSError, (err, msg): - raise CreatorError("Failed to execute %%post script " - "with '%s' : %s" % (s.interp, msg)) - finally: - os.unlink(path) - - def __save_repo_keys(self, repodata): - if not repodata: - return None - - gpgkeydir = "/etc/pki/rpm-gpg" - fs.makedirs(self._instroot + gpgkeydir) - for repo in repodata: - if repo["repokey"]: - repokey = gpgkeydir + "/RPM-GPG-KEY-%s" % repo["name"] - shutil.copy(repo["repokey"], self._instroot + repokey) - - def configure(self, repodata = None): - """Configure the system image according to the kickstart. - - This method applies the (e.g. keyboard or network) configuration - specified in the kickstart and executes the kickstart %post scripts. - - If necessary, it also prepares the image to be bootable by e.g. - creating an initrd and bootloader configuration. - - """ - ksh = self.ks.handler - - msger.info('Applying configurations ...') - try: - kickstart.LanguageConfig(self._instroot).apply(ksh.lang) - kickstart.KeyboardConfig(self._instroot).apply(ksh.keyboard) - kickstart.TimezoneConfig(self._instroot).apply(ksh.timezone) - #kickstart.AuthConfig(self._instroot).apply(ksh.authconfig) - kickstart.FirewallConfig(self._instroot).apply(ksh.firewall) - kickstart.RootPasswordConfig(self._instroot).apply(ksh.rootpw) - kickstart.UserConfig(self._instroot).apply(ksh.user) - kickstart.ServicesConfig(self._instroot).apply(ksh.services) - kickstart.XConfig(self._instroot).apply(ksh.xconfig) - kickstart.NetworkConfig(self._instroot).apply(ksh.network) - kickstart.RPMMacroConfig(self._instroot).apply(self.ks) - kickstart.DesktopConfig(self._instroot).apply(ksh.desktop) - self.__save_repo_keys(repodata) - kickstart.MoblinRepoConfig(self._instroot).apply(ksh.repo, repodata, self.repourl) - except: - msger.warning("Failed to apply configuration to image") - raise - - self._create_bootconfig() - self.__run_post_scripts() - - def launch_shell(self, launch): - """Launch a shell in the install root. - - This method is launches a bash shell chroot()ed in the install root; - this can be useful for debugging. - - """ - if launch: - msger.info("Launching shell. Exit to continue.") - subprocess.call(["/bin/bash"], preexec_fn = self._chroot) - - def do_genchecksum(self, image_name): - if not self._genchecksum: - return - - md5sum = misc.get_md5sum(image_name) - with open(image_name + ".md5sum", "w") as f: - f.write("%s %s" % (md5sum, os.path.basename(image_name))) - self.outimage.append(image_name+".md5sum") - - def package(self, destdir = "."): - """Prepares the created image for final delivery. - - In its simplest form, this method merely copies the install root to the - supplied destination directory; other subclasses may choose to package - the image by e.g. creating a bootable ISO containing the image and - bootloader configuration. - - destdir -- the directory into which the final image should be moved; - this defaults to the current directory. - - """ - self._stage_final_image() - - if not os.path.exists(destdir): - fs.makedirs(destdir) - - if self._recording_pkgs: - self._save_recording_pkgs(destdir) - - # For image formats with two or multiple image files, it will be - # better to put them under a directory - if self.image_format in ("raw", "vmdk", "vdi", "nand", "mrstnand"): - destdir = os.path.join(destdir, "%s-%s" \ - % (self.name, self.image_format)) - msger.debug("creating destination dir: %s" % destdir) - fs.makedirs(destdir) - - # Ensure all data is flushed to _outdir - runner.quiet('sync') - - misc.check_space_pre_cp(self._outdir, destdir) - for f in os.listdir(self._outdir): - shutil.move(os.path.join(self._outdir, f), - os.path.join(destdir, f)) - self.outimage.append(os.path.join(destdir, f)) - self.do_genchecksum(os.path.join(destdir, f)) - - def print_outimage_info(self): - msg = "The new image can be found here:\n" - self.outimage.sort() - for file in self.outimage: - msg += ' %s\n' % os.path.abspath(file) - - msger.info(msg) - - def check_depend_tools(self): - for tool in self._dep_checks: - fs.find_binary_path(tool) - - def package_output(self, image_format, destdir = ".", package="none"): - if not package or package == "none": - return - - destdir = os.path.abspath(os.path.expanduser(destdir)) - (pkg, comp) = os.path.splitext(package) - if comp: - comp=comp.lstrip(".") - - if pkg == "tar": - if comp: - dst = "%s/%s-%s.tar.%s" %\ - (destdir, self.name, image_format, comp) - else: - dst = "%s/%s-%s.tar" %\ - (destdir, self.name, image_format) - - msger.info("creating %s" % dst) - tar = tarfile.open(dst, "w:" + comp) - - for file in self.outimage: - msger.info("adding %s to %s" % (file, dst)) - tar.add(file, - arcname=os.path.join("%s-%s" \ - % (self.name, image_format), - os.path.basename(file))) - if os.path.isdir(file): - shutil.rmtree(file, ignore_errors = True) - else: - os.remove(file) - - tar.close() - - '''All the file in outimage has been packaged into tar.* file''' - self.outimage = [dst] - - def release_output(self, config, destdir, release): - """ Create release directory and files - """ - - def _rpath(fn): - """ release path """ - return os.path.join(destdir, fn) - - outimages = self.outimage - - # new ks - new_kspath = _rpath(self.name+'.ks') - with open(config) as fr: - with open(new_kspath, "w") as wf: - # When building a release we want to make sure the .ks - # file generates the same build even when --release not used. - wf.write(fr.read().replace("@BUILD_ID@", release)) - outimages.append(new_kspath) - - # save log file, logfile is only available in creator attrs - if hasattr(self, 'logfile') and not self.logfile: - log_path = _rpath(self.name + ".log") - # touch the log file, else outimages will filter it out - with open(log_path, 'w') as wf: - wf.write('') - msger.set_logfile(log_path) - outimages.append(_rpath(self.name + ".log")) - - # rename iso and usbimg - for f in os.listdir(destdir): - if f.endswith(".iso"): - newf = f[:-4] + '.img' - elif f.endswith(".usbimg"): - newf = f[:-7] + '.img' - else: - continue - os.rename(_rpath(f), _rpath(newf)) - outimages.append(_rpath(newf)) - - # generate MD5SUMS - with open(_rpath("MD5SUMS"), "w") as wf: - for f in os.listdir(destdir): - if f == "MD5SUMS": - continue - - if os.path.isdir(os.path.join(destdir, f)): - continue - - md5sum = misc.get_md5sum(_rpath(f)) - # There needs to be two spaces between the sum and - # filepath to match the syntax with md5sum. - # This way also md5sum -c MD5SUMS can be used by users - wf.write("%s *%s\n" % (md5sum, f)) - - outimages.append("%s/MD5SUMS" % destdir) - - # Filter out the nonexist file - for fp in outimages[:]: - if not os.path.exists("%s" % fp): - outimages.remove(fp) - - def copy_kernel(self): - """ Copy kernel files to the outimage directory. - NOTE: This needs to be called before unmounting the instroot. - """ - - if not self._need_copy_kernel: - return - - if not os.path.exists(self.destdir): - os.makedirs(self.destdir) - - for kernel in glob.glob("%s/boot/vmlinuz-*" % self._instroot): - kernelfilename = "%s/%s-%s" % (self.destdir, - self.name, - os.path.basename(kernel)) - msger.info('copy kernel file %s as %s' % (os.path.basename(kernel), - kernelfilename)) - shutil.copy(kernel, kernelfilename) - self.outimage.append(kernelfilename) - - def copy_attachment(self): - """ Subclass implement it to handle attachment files - NOTE: This needs to be called before unmounting the instroot. - """ - pass - - def get_pkg_manager(self): - return self.pkgmgr(target_arch = self.target_arch, - instroot = self._instroot, - cachedir = self.cachedir) diff --git a/scripts/lib/mic/imager/direct.py b/scripts/lib/mic/imager/direct.py deleted file mode 100644 index 7e2b63a37c..0000000000 --- a/scripts/lib/mic/imager/direct.py +++ /dev/null @@ -1,391 +0,0 @@ -# ex:ts=4:sw=4:sts=4:et -# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- -# -# Copyright (c) 2013, Intel Corporation. -# All rights reserved. -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License version 2 as -# published by the Free Software Foundation. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., -# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. -# -# DESCRIPTION -# This implements the 'direct' image creator class for 'wic', based -# loosely on the raw image creator from 'mic' -# -# AUTHORS -# Tom Zanussi <tom.zanussi (at] linux.intel.com> -# - -import os -import stat -import shutil - -from mic import kickstart, msger -from mic.utils import fs_related, runner, misc -from mic.utils.partitionedfs import PartitionedMount -from mic.utils.errors import CreatorError, MountError -from mic.imager.baseimager import BaseImageCreator -from mic.utils.oe.misc import * -from mic.plugin import pluginmgr - -disk_methods = { - "do_install_disk":None, -} - -class DirectImageCreator(BaseImageCreator): - """ - Installs a system into a file containing a partitioned disk image. - - DirectImageCreator is an advanced ImageCreator subclass; an image - file is formatted with a partition table, each partition created - from a rootfs or other OpenEmbedded build artifact and dd'ed into - the virtual disk. The disk image can subsequently be dd'ed onto - media and used on actual hardware. - """ - - def __init__(self, oe_builddir, image_output_dir, rootfs_dir, bootimg_dir, - kernel_dir, native_sysroot, hdddir, staging_data_dir, - creatoropts=None, pkgmgr=None, compress_image=None, - generate_bmap=None, fstab_entry="uuid"): - """ - Initialize a DirectImageCreator instance. - - This method takes the same arguments as ImageCreator.__init__() - """ - BaseImageCreator.__init__(self, creatoropts, pkgmgr) - - self.__instimage = None - self.__imgdir = None - self.__disks = {} - self.__disk_format = "direct" - self._disk_names = [] - self._ptable_format = self.ks.handler.bootloader.ptable - self.use_uuid = fstab_entry == "uuid" - self.compress_image = compress_image - self.bmap_needed = generate_bmap - - self.oe_builddir = oe_builddir - if image_output_dir: - self.tmpdir = image_output_dir - self.cachedir = "%s/cache" % image_output_dir - self.rootfs_dir = rootfs_dir - self.bootimg_dir = bootimg_dir - self.kernel_dir = kernel_dir - self.native_sysroot = native_sysroot - self.hdddir = hdddir - self.staging_data_dir = staging_data_dir - - def __write_fstab(self, image_rootfs): - """overriden to generate fstab (temporarily) in rootfs. This - is called from mount_instroot, make sure it doesn't get called - from BaseImage.mount()""" - if image_rootfs is None: - return None - - fstab = image_rootfs + "/etc/fstab" - if not os.path.isfile(fstab): - return None - - parts = self._get_parts() - - self._save_fstab(fstab) - fstab_lines = self._get_fstab(fstab, parts) - self._update_fstab(fstab_lines, parts) - self._write_fstab(fstab, fstab_lines) - - return fstab - - def _update_fstab(self, fstab_lines, parts): - """Assume partition order same as in wks""" - for num, p in enumerate(parts, 1): - if not p.mountpoint or p.mountpoint == "/" or p.mountpoint == "/boot": - continue - if self._ptable_format == 'msdos' and num > 3: - device_name = "/dev/" + p.disk + str(num + 1) - else: - device_name = "/dev/" + p.disk + str(num) - - opts = "defaults" - if p.fsopts: - opts = p.fsopts - - fstab_entry = device_name + "\t" + \ - p.mountpoint + "\t" + \ - p.fstype + "\t" + \ - opts + "\t0\t0\n" - fstab_lines.append(fstab_entry) - - def _write_fstab(self, fstab, fstab_lines): - fstab = open(fstab, "w") - for line in fstab_lines: - fstab.write(line) - fstab.close() - - def _save_fstab(self, fstab): - """Save the current fstab in rootfs""" - shutil.copyfile(fstab, fstab + ".orig") - - def _restore_fstab(self, fstab): - """Restore the saved fstab in rootfs""" - if fstab is None: - return - shutil.move(fstab + ".orig", fstab) - - def _get_fstab(self, fstab, parts): - """Return the desired contents of /etc/fstab.""" - f = open(fstab, "r") - fstab_contents = f.readlines() - f.close() - - return fstab_contents - - def set_bootimg_dir(self, bootimg_dir): - """ - Accessor for bootimg_dir, the actual location used for the source - of the bootimg. Should be set by source plugins (only if they - change the default bootimg source) so the correct info gets - displayed for print_outimage_info(). - """ - self.bootimg_dir = bootimg_dir - - def _get_parts(self): - if not self.ks: - raise CreatorError("Failed to get partition info, " - "please check your kickstart setting.") - - # Set a default partition if no partition is given out - if not self.ks.handler.partition.partitions: - partstr = "part / --size 1900 --ondisk sda --fstype=ext3" - args = partstr.split() - pd = self.ks.handler.partition.parse(args[1:]) - if pd not in self.ks.handler.partition.partitions: - self.ks.handler.partition.partitions.append(pd) - - # partitions list from kickstart file - return kickstart.get_partitions(self.ks) - - def get_disk_names(self): - """ Returns a list of physical target disk names (e.g., 'sdb') which - will be created. """ - - if self._disk_names: - return self._disk_names - - #get partition info from ks handler - parts = self._get_parts() - - for i in range(len(parts)): - if parts[i].disk: - disk_name = parts[i].disk - else: - raise CreatorError("Failed to create disks, no --ondisk " - "specified in partition line of ks file") - - if parts[i].mountpoint and not parts[i].fstype: - raise CreatorError("Failed to create disks, no --fstype " - "specified for partition with mountpoint " - "'%s' in the ks file") - - self._disk_names.append(disk_name) - - return self._disk_names - - def _full_name(self, name, extention): - """ Construct full file name for a file we generate. """ - return "%s-%s.%s" % (self.name, name, extention) - - def _full_path(self, path, name, extention): - """ Construct full file path to a file we generate. """ - return os.path.join(path, self._full_name(name, extention)) - - def get_default_source_plugin(self): - """ - The default source plugin i.e. the plugin that's consulted for - overall image generation tasks outside of any particular - partition. For convenience, we just hang it off the - bootloader handler since it's the one non-partition object in - any setup. By default the default plugin is set to the same - plugin as the /boot partition; since we hang it off the - bootloader object, the default can be explicitly set using the - --source bootloader param. - """ - return self.ks.handler.bootloader.source - - # - # Actual implemention - # - def _mount_instroot(self, base_on = None): - """ - For 'wic', we already have our build artifacts and don't want - to loop mount anything to install into, we just create - filesystems from the artifacts directly and combine them into - a partitioned image. - - We still want to reuse as much of the basic mic machinery - though; despite the fact that we don't actually do loop or any - other kind of mounting we still want to do many of the same - things to prepare images, so we basically just adapt to the - basic framework and reinterpret what 'mounting' means in our - context. - - _instroot would normally be something like - /var/tmp/wic/build/imgcreate-s_9AKQ/install_root, for - installing packages, etc. We don't currently need to do that, - so we simplify life by just using /var/tmp/wic/build as our - workdir. - """ - parts = self._get_parts() - - self.__instimage = PartitionedMount(self._instroot) - - for p in parts: - # as a convenience, set source to the boot partition source - # instead of forcing it to be set via bootloader --source - if not self.ks.handler.bootloader.source and p.mountpoint == "/boot": - self.ks.handler.bootloader.source = p.source - - for p in parts: - # need to create the filesystems in order to get their - # sizes before we can add them and do the layout. - # PartitionedMount.mount() actually calls __format_disks() - # to create the disk images and carve out the partitions, - # then self.install() calls PartitionedMount.install() - # which calls __install_partitition() for each partition - # to dd the fs into the partitions. It would be nice to - # be able to use e.g. ExtDiskMount etc to create the - # filesystems, since that's where existing e.g. mkfs code - # is, but those are only created after __format_disks() - # which needs the partition sizes so needs them created - # before its called. Well, the existing setup is geared - # to installing packages into mounted filesystems - maybe - # when/if we need to actually do package selection we - # should modify things to use those objects, but for now - # we can avoid that. - - fstab = self.__write_fstab(self.rootfs_dir.get("ROOTFS_DIR")) - - p.prepare(self, self.workdir, self.oe_builddir, self.rootfs_dir, - self.bootimg_dir, self.kernel_dir, self.native_sysroot) - - self._restore_fstab(fstab) - - self.__instimage.add_partition(int(p.size), - p.disk, - p.mountpoint, - p.source_file, - p.fstype, - p.label, - fsopts = p.fsopts, - boot = p.active, - align = p.align, - part_type = p.part_type) - - self.__instimage.layout_partitions(self._ptable_format) - - self.__imgdir = self.workdir - for disk_name, disk in self.__instimage.disks.items(): - full_path = self._full_path(self.__imgdir, disk_name, "direct") - msger.debug("Adding disk %s as %s with size %s bytes" \ - % (disk_name, full_path, disk['min_size'])) - disk_obj = fs_related.DiskImage(full_path, disk['min_size']) - self.__disks[disk_name] = disk_obj - self.__instimage.add_disk(disk_name, disk_obj) - - self.__instimage.mount() - - def install(self, repo_urls=None): - """ - Install fs images into partitions - """ - for disk_name, disk in self.__instimage.disks.items(): - full_path = self._full_path(self.__imgdir, disk_name, "direct") - msger.debug("Installing disk %s as %s with size %s bytes" \ - % (disk_name, full_path, disk['min_size'])) - self.__instimage.install(full_path) - - def configure(self, repodata = None): - """ - Configure the system image according to kickstart. - - For now, it just prepares the image to be bootable by e.g. - creating and installing a bootloader configuration. - """ - source_plugin = self.get_default_source_plugin() - if source_plugin: - self._source_methods = pluginmgr.get_source_plugin_methods(source_plugin, disk_methods) - for disk_name, disk in self.__instimage.disks.items(): - self._source_methods["do_install_disk"](disk, disk_name, self, - self.workdir, - self.oe_builddir, - self.bootimg_dir, - self.kernel_dir, - self.native_sysroot) - - def print_outimage_info(self): - """ - Print the image(s) and artifacts used, for the user. - """ - msg = "The new image(s) can be found here:\n" - - parts = self._get_parts() - - for disk_name, disk in self.__instimage.disks.items(): - full_path = self._full_path(self.__imgdir, disk_name, "direct") - msg += ' %s\n\n' % full_path - - msg += 'The following build artifacts were used to create the image(s):\n' - for p in parts: - if p.get_rootfs() is None: - continue - if p.mountpoint == '/': - str = ':' - else: - str = '["%s"]:' % p.label - msg += ' ROOTFS_DIR%s%s\n' % (str.ljust(20), p.get_rootfs()) - - msg += ' BOOTIMG_DIR: %s\n' % self.bootimg_dir - msg += ' KERNEL_DIR: %s\n' % self.kernel_dir - msg += ' NATIVE_SYSROOT: %s\n' % self.native_sysroot - - msger.info(msg) - - def _get_boot_config(self): - """ - Return the rootdev/root_part_uuid (if specified by - --part-type) - - Assume partition order same as in wks - """ - rootdev = None - root_part_uuid = None - parts = self._get_parts() - for num, p in enumerate(parts, 1): - if p.mountpoint == "/": - part = '' - if p.disk.startswith('mmcblk'): - part = 'p' - - if self._ptable_format == 'msdos' and num > 3: - rootdev = "/dev/%s%s%-d" % (p.disk, part, num + 1) - else: - rootdev = "/dev/%s%s%-d" % (p.disk, part, num) - root_part_uuid = p.part_type - - return (rootdev, root_part_uuid) - - def _unmount_instroot(self): - if not self.__instimage is None: - try: - self.__instimage.cleanup() - except MountError, err: - msger.warning("%s" % err) - diff --git a/scripts/lib/mic/imager/fs.py b/scripts/lib/mic/imager/fs.py deleted file mode 100644 index d53b29cb47..0000000000 --- a/scripts/lib/mic/imager/fs.py +++ /dev/null @@ -1,99 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os - -from mic import msger -from mic.utils import runner, misc -from mic.utils.errors import CreatorError -from mic.utils.fs_related import find_binary_path -from mic.imager.baseimager import BaseImageCreator - -class FsImageCreator(BaseImageCreator): - def __init__(self, cfgmgr = None, pkgmgr = None): - self.zips = { - "tar.bz2" : "" - } - BaseImageCreator.__init__(self, cfgmgr, pkgmgr) - self._fstype = None - self._fsopts = None - self._include_src = False - - def package(self, destdir = "."): - - ignores = ["/dev/fd", - "/dev/stdin", - "/dev/stdout", - "/dev/stderr", - "/etc/mtab"] - - if not os.path.exists(destdir): - os.makedirs(destdir) - - if self._recording_pkgs: - self._save_recording_pkgs(destdir) - - if not self.pack_to: - fsdir = os.path.join(destdir, self.name) - - misc.check_space_pre_cp(self._instroot, destdir) - msger.info("Copying %s to %s ..." % (self._instroot, fsdir)) - runner.show(['cp', "-af", self._instroot, fsdir]) - - for exclude in ignores: - if os.path.exists(fsdir + exclude): - os.unlink(fsdir + exclude) - - self.outimage.append(fsdir) - - else: - (tar, comp) = os.path.splitext(self.pack_to) - try: - tarcreat = {'.tar': '-cf', - '.gz': '-czf', - '.bz2': '-cjf', - '.tgz': '-czf', - '.tbz': '-cjf'}[comp] - except KeyError: - raise CreatorError("Unsupported comression for this image type:" - " '%s', try '.tar', '.tar.gz', etc" % comp) - - dst = os.path.join(destdir, self.pack_to) - msger.info("Pack rootfs to %s. Please wait..." % dst) - - tar = find_binary_path('tar') - tar_cmdline = [tar, "--numeric-owner", - "--preserve-permissions", - "--preserve-order", - "--one-file-system", - "--directory", - self._instroot] - for ignore_entry in ignores: - if ignore_entry.startswith('/'): - ignore_entry = ignore_entry[1:] - - tar_cmdline.append("--exclude=%s" % (ignore_entry)) - - tar_cmdline.extend([tarcreat, dst, "."]) - - rc = runner.show(tar_cmdline) - if rc: - raise CreatorError("Failed compress image with tar.bz2. " - "Cmdline: %s" % (" ".join(tar_cmdline))) - - self.outimage.append(dst) - diff --git a/scripts/lib/mic/imager/livecd.py b/scripts/lib/mic/imager/livecd.py deleted file mode 100644 index e36f4a76c6..0000000000 --- a/scripts/lib/mic/imager/livecd.py +++ /dev/null @@ -1,750 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os, sys -import glob -import shutil - -from mic import kickstart, msger -from mic.utils import fs_related, runner, misc -from mic.utils.errors import CreatorError -from mic.imager.loop import LoopImageCreator - - -class LiveImageCreatorBase(LoopImageCreator): - """A base class for LiveCD image creators. - - This class serves as a base class for the architecture-specific LiveCD - image creator subclass, LiveImageCreator. - - LiveImageCreator creates a bootable ISO containing the system image, - bootloader, bootloader configuration, kernel and initramfs. - """ - - def __init__(self, creatoropts = None, pkgmgr = None): - """Initialise a LiveImageCreator instance. - - This method takes the same arguments as ImageCreator.__init__(). - """ - LoopImageCreator.__init__(self, creatoropts, pkgmgr) - - #Controls whether to use squashfs to compress the image. - self.skip_compression = False - - #Controls whether an image minimizing snapshot should be created. - # - #This snapshot can be used when copying the system image from the ISO in - #order to minimize the amount of data that needs to be copied; simply, - #it makes it possible to create a version of the image's filesystem with - #no spare space. - self.skip_minimize = False - - #A flag which indicates i act as a convertor default false - self.actasconvertor = False - - #The bootloader timeout from kickstart. - if self.ks: - self._timeout = kickstart.get_timeout(self.ks, 10) - else: - self._timeout = 10 - - #The default kernel type from kickstart. - if self.ks: - self._default_kernel = kickstart.get_default_kernel(self.ks, - "kernel") - else: - self._default_kernel = None - - if self.ks: - parts = kickstart.get_partitions(self.ks) - if len(parts) > 1: - raise CreatorError("Can't support multi partitions in ks file " - "for this image type") - # FIXME: rename rootfs img to self.name, - # else can't find files when create iso - self._instloops[0]['name'] = self.name + ".img" - - self.__isodir = None - - self.__modules = ["=ata", - "sym53c8xx", - "aic7xxx", - "=usb", - "=firewire", - "=mmc", - "=pcmcia", - "mptsas"] - if self.ks: - self.__modules.extend(kickstart.get_modules(self.ks)) - - self._dep_checks.extend(["isohybrid", - "unsquashfs", - "mksquashfs", - "dd", - "genisoimage"]) - - # - # Hooks for subclasses - # - def _configure_bootloader(self, isodir): - """Create the architecture specific booloader configuration. - - This is the hook where subclasses must create the booloader - configuration in order to allow a bootable ISO to be built. - - isodir -- the directory where the contents of the ISO are to - be staged - """ - raise CreatorError("Bootloader configuration is arch-specific, " - "but not implemented for this arch!") - def _get_menu_options(self): - """Return a menu options string for syslinux configuration. - """ - if self.ks is None: - return "liveinst autoinst" - r = kickstart.get_menu_args(self.ks) - return r - - def _get_kernel_options(self): - """Return a kernel options string for bootloader configuration. - - This is the hook where subclasses may specify a set of kernel - options which should be included in the images bootloader - configuration. - - A sensible default implementation is provided. - """ - - if self.ks is None: - r = "ro rd.live.image" - else: - r = kickstart.get_kernel_args(self.ks) - - return r - - def _get_mkisofs_options(self, isodir): - """Return the architecture specific mkisosfs options. - - This is the hook where subclasses may specify additional arguments - to mkisofs, e.g. to enable a bootable ISO to be built. - - By default, an empty list is returned. - """ - return [] - - # - # Helpers for subclasses - # - def _has_checkisomd5(self): - """Check whether checkisomd5 is available in the install root.""" - def _exists(path): - return os.path.exists(self._instroot + path) - - if _exists("/usr/bin/checkisomd5") and os.path.exists("/usr/bin/implantisomd5"): - return True - - return False - - def __restore_file(self,path): - try: - os.unlink(path) - except: - pass - if os.path.exists(path + '.rpmnew'): - os.rename(path + '.rpmnew', path) - - def _mount_instroot(self, base_on = None): - LoopImageCreator._mount_instroot(self, base_on) - self.__write_initrd_conf(self._instroot + "/etc/sysconfig/mkinitrd") - self.__write_dracut_conf(self._instroot + "/etc/dracut.conf.d/02livecd.conf") - - def _unmount_instroot(self): - self.__restore_file(self._instroot + "/etc/sysconfig/mkinitrd") - self.__restore_file(self._instroot + "/etc/dracut.conf.d/02livecd.conf") - LoopImageCreator._unmount_instroot(self) - - def __ensure_isodir(self): - if self.__isodir is None: - self.__isodir = self._mkdtemp("iso-") - return self.__isodir - - def _get_isodir(self): - return self.__ensure_isodir() - - def _set_isodir(self, isodir = None): - self.__isodir = isodir - - def _create_bootconfig(self): - """Configure the image so that it's bootable.""" - self._configure_bootloader(self.__ensure_isodir()) - - def _get_post_scripts_env(self, in_chroot): - env = LoopImageCreator._get_post_scripts_env(self, in_chroot) - - if not in_chroot: - env["LIVE_ROOT"] = self.__ensure_isodir() - - return env - def __write_dracut_conf(self, path): - if not os.path.exists(os.path.dirname(path)): - fs_related.makedirs(os.path.dirname(path)) - f = open(path, "a") - f.write('add_dracutmodules+=" dmsquash-live pollcdrom "') - f.close() - - def __write_initrd_conf(self, path): - content = "" - if not os.path.exists(os.path.dirname(path)): - fs_related.makedirs(os.path.dirname(path)) - f = open(path, "w") - - content += 'LIVEOS="yes"\n' - content += 'PROBE="no"\n' - content += 'MODULES+="squashfs ext3 ext2 vfat msdos "\n' - content += 'MODULES+="sr_mod sd_mod ide-cd cdrom "\n' - - for module in self.__modules: - if module == "=usb": - content += 'MODULES+="ehci_hcd uhci_hcd ohci_hcd "\n' - content += 'MODULES+="usb_storage usbhid "\n' - elif module == "=firewire": - content += 'MODULES+="firewire-sbp2 firewire-ohci "\n' - content += 'MODULES+="sbp2 ohci1394 ieee1394 "\n' - elif module == "=mmc": - content += 'MODULES+="mmc_block sdhci sdhci-pci "\n' - elif module == "=pcmcia": - content += 'MODULES+="pata_pcmcia "\n' - else: - content += 'MODULES+="' + module + ' "\n' - f.write(content) - f.close() - - def __create_iso(self, isodir): - iso = self._outdir + "/" + self.name + ".iso" - genisoimage = fs_related.find_binary_path("genisoimage") - args = [genisoimage, - "-J", "-r", - "-hide-rr-moved", "-hide-joliet-trans-tbl", - "-V", self.fslabel, - "-o", iso] - - args.extend(self._get_mkisofs_options(isodir)) - - args.append(isodir) - - if runner.show(args) != 0: - raise CreatorError("ISO creation failed!") - - """ It should be ok still even if you haven't isohybrid """ - isohybrid = None - try: - isohybrid = fs_related.find_binary_path("isohybrid") - except: - pass - - if isohybrid: - args = [isohybrid, "-partok", iso ] - if runner.show(args) != 0: - raise CreatorError("Hybrid ISO creation failed!") - - self.__implant_md5sum(iso) - - def __implant_md5sum(self, iso): - """Implant an isomd5sum.""" - if os.path.exists("/usr/bin/implantisomd5"): - implantisomd5 = "/usr/bin/implantisomd5" - else: - msger.warning("isomd5sum not installed; not setting up mediacheck") - implantisomd5 = "" - return - - runner.show([implantisomd5, iso]) - - def _stage_final_image(self): - try: - fs_related.makedirs(self.__ensure_isodir() + "/LiveOS") - - minimal_size = self._resparse() - - if not self.skip_minimize: - fs_related.create_image_minimizer(self.__isodir + \ - "/LiveOS/osmin.img", - self._image, - minimal_size) - - if self.skip_compression: - shutil.move(self._image, self.__isodir + "/LiveOS/ext3fs.img") - else: - fs_related.makedirs(os.path.join( - os.path.dirname(self._image), - "LiveOS")) - shutil.move(self._image, - os.path.join(os.path.dirname(self._image), - "LiveOS", "ext3fs.img")) - fs_related.mksquashfs(os.path.dirname(self._image), - self.__isodir + "/LiveOS/squashfs.img") - - self.__create_iso(self.__isodir) - - if self.pack_to: - isoimg = os.path.join(self._outdir, self.name + ".iso") - packimg = os.path.join(self._outdir, self.pack_to) - misc.packing(packimg, isoimg) - os.unlink(isoimg) - - finally: - shutil.rmtree(self.__isodir, ignore_errors = True) - self.__isodir = None - -class x86LiveImageCreator(LiveImageCreatorBase): - """ImageCreator for x86 machines""" - def _get_mkisofs_options(self, isodir): - return [ "-b", "isolinux/isolinux.bin", - "-c", "isolinux/boot.cat", - "-no-emul-boot", "-boot-info-table", - "-boot-load-size", "4" ] - - def _get_required_packages(self): - return ["syslinux", "syslinux-extlinux"] + \ - LiveImageCreatorBase._get_required_packages(self) - - def _get_isolinux_stanzas(self, isodir): - return "" - - def __find_syslinux_menu(self): - for menu in ["vesamenu.c32", "menu.c32"]: - if os.path.isfile(self._instroot + "/usr/share/syslinux/" + menu): - return menu - - raise CreatorError("syslinux not installed : " - "no suitable /usr/share/syslinux/*menu.c32 found") - - def __find_syslinux_mboot(self): - # - # We only need the mboot module if we have any xen hypervisors - # - if not glob.glob(self._instroot + "/boot/xen.gz*"): - return None - - return "mboot.c32" - - def __copy_syslinux_files(self, isodir, menu, mboot = None): - files = ["isolinux.bin", menu] - if mboot: - files += [mboot] - - for f in files: - path = self._instroot + "/usr/share/syslinux/" + f - - if not os.path.isfile(path): - raise CreatorError("syslinux not installed : " - "%s not found" % path) - - shutil.copy(path, isodir + "/isolinux/") - - def __copy_syslinux_background(self, isodest): - background_path = self._instroot + \ - "/usr/share/branding/default/syslinux/syslinux-vesa-splash.jpg" - - if not os.path.exists(background_path): - return False - - shutil.copyfile(background_path, isodest) - - return True - - def __copy_kernel_and_initramfs(self, isodir, version, index): - bootdir = self._instroot + "/boot" - isDracut = False - - if self._alt_initrd_name: - src_initrd_path = os.path.join(bootdir, self._alt_initrd_name) - else: - if os.path.exists(bootdir + "/initramfs-" + version + ".img"): - src_initrd_path = os.path.join(bootdir, "initramfs-" +version+ ".img") - isDracut = True - else: - src_initrd_path = os.path.join(bootdir, "initrd-" +version+ ".img") - - try: - msger.debug("copy %s to %s" % (bootdir + "/vmlinuz-" + version, isodir + "/isolinux/vmlinuz" + index)) - shutil.copyfile(bootdir + "/vmlinuz-" + version, - isodir + "/isolinux/vmlinuz" + index) - - msger.debug("copy %s to %s" % (src_initrd_path, isodir + "/isolinux/initrd" + index + ".img")) - shutil.copyfile(src_initrd_path, - isodir + "/isolinux/initrd" + index + ".img") - except: - raise CreatorError("Unable to copy valid kernels or initrds, " - "please check the repo.") - - is_xen = False - if os.path.exists(bootdir + "/xen.gz-" + version[:-3]): - shutil.copyfile(bootdir + "/xen.gz-" + version[:-3], - isodir + "/isolinux/xen" + index + ".gz") - is_xen = True - - return (is_xen,isDracut) - - def __is_default_kernel(self, kernel, kernels): - if len(kernels) == 1: - return True - - if kernel == self._default_kernel: - return True - - if kernel.startswith("kernel-") and kernel[7:] == self._default_kernel: - return True - - return False - - def __get_basic_syslinux_config(self, **args): - return """ -default %(menu)s -timeout %(timeout)d - -%(background)s -menu title Welcome to %(distroname)s! -menu color border 0 #ffffffff #00000000 -menu color sel 7 #ff000000 #ffffffff -menu color title 0 #ffffffff #00000000 -menu color tabmsg 0 #ffffffff #00000000 -menu color unsel 0 #ffffffff #00000000 -menu color hotsel 0 #ff000000 #ffffffff -menu color hotkey 7 #ffffffff #ff000000 -menu color timeout_msg 0 #ffffffff #00000000 -menu color timeout 0 #ffffffff #00000000 -menu color cmdline 0 #ffffffff #00000000 -menu hidden -menu clear -""" % args - - def __get_image_stanza(self, is_xen, isDracut, **args): - if isDracut: - args["rootlabel"] = "live:CDLABEL=%(fslabel)s" % args - else: - args["rootlabel"] = "CDLABEL=%(fslabel)s" % args - if not is_xen: - template = """label %(short)s - menu label %(long)s - kernel vmlinuz%(index)s - append initrd=initrd%(index)s.img root=%(rootlabel)s rootfstype=iso9660 %(liveargs)s %(extra)s -""" - else: - template = """label %(short)s - menu label %(long)s - kernel mboot.c32 - append xen%(index)s.gz --- vmlinuz%(index)s root=%(rootlabel)s rootfstype=iso9660 %(liveargs)s %(extra)s --- initrd%(index)s.img -""" - return template % args - - def __get_image_stanzas(self, isodir): - versions = [] - kernels = self._get_kernel_versions() - for kernel in kernels: - for version in kernels[kernel]: - versions.append(version) - - if not versions: - raise CreatorError("Unable to find valid kernels, " - "please check the repo") - - kernel_options = self._get_kernel_options() - - """ menu can be customized highly, the format is: - - short_name1:long_name1:extra_opts1;short_name2:long_name2:extra_opts2 - - e.g.: autoinst:InstallationOnly:systemd.unit=installer-graphical.service - but in order to keep compatible with old format, these are still ok: - - liveinst autoinst - liveinst;autoinst - liveinst::;autoinst:: - """ - oldmenus = {"basic": { - "short": "basic", - "long": "Installation Only (Text based)", - "extra": "basic nosplash 4" - }, - "liveinst": { - "short": "liveinst", - "long": "Installation Only", - "extra": "liveinst nosplash 4" - }, - "autoinst": { - "short": "autoinst", - "long": "Autoinstall (Deletes all existing content)", - "extra": "autoinst nosplash 4" - }, - "netinst": { - "short": "netinst", - "long": "Network Installation", - "extra": "netinst 4" - }, - "verify": { - "short": "check", - "long": "Verify and", - "extra": "check" - } - } - menu_options = self._get_menu_options() - menus = menu_options.split(";") - for i in range(len(menus)): - menus[i] = menus[i].split(":") - if len(menus) == 1 and len(menus[0]) == 1: - """ Keep compatible with the old usage way """ - menus = menu_options.split() - for i in range(len(menus)): - menus[i] = [menus[i]] - - cfg = "" - - default_version = None - default_index = None - index = "0" - netinst = None - for version in versions: - (is_xen, isDracut) = self.__copy_kernel_and_initramfs(isodir, version, index) - if index == "0": - self._isDracut = isDracut - - default = self.__is_default_kernel(kernel, kernels) - - if default: - long = "Boot %s" % self.distro_name - elif kernel.startswith("kernel-"): - long = "Boot %s(%s)" % (self.name, kernel[7:]) - else: - long = "Boot %s(%s)" % (self.name, kernel) - - oldmenus["verify"]["long"] = "%s %s" % (oldmenus["verify"]["long"], - long) - # tell dracut not to ask for LUKS passwords or activate mdraid sets - if isDracut: - kern_opts = kernel_options + " rd.luks=0 rd.md=0 rd.dm=0" - else: - kern_opts = kernel_options - - cfg += self.__get_image_stanza(is_xen, isDracut, - fslabel = self.fslabel, - liveargs = kern_opts, - long = long, - short = "linux" + index, - extra = "", - index = index) - - if default: - cfg += "menu default\n" - default_version = version - default_index = index - - for menu in menus: - if not menu[0]: - continue - short = menu[0] + index - - if len(menu) >= 2: - long = menu[1] - else: - if menu[0] in oldmenus.keys(): - if menu[0] == "verify" and not self._has_checkisomd5(): - continue - if menu[0] == "netinst": - netinst = oldmenus[menu[0]] - continue - long = oldmenus[menu[0]]["long"] - extra = oldmenus[menu[0]]["extra"] - else: - long = short.upper() + " X" + index - extra = "" - - if len(menu) >= 3: - extra = menu[2] - - cfg += self.__get_image_stanza(is_xen, isDracut, - fslabel = self.fslabel, - liveargs = kernel_options, - long = long, - short = short, - extra = extra, - index = index) - - index = str(int(index) + 1) - - if not default_version: - default_version = versions[0] - if not default_index: - default_index = "0" - - if netinst: - cfg += self.__get_image_stanza(is_xen, isDracut, - fslabel = self.fslabel, - liveargs = kernel_options, - long = netinst["long"], - short = netinst["short"], - extra = netinst["extra"], - index = default_index) - - return cfg - - def __get_memtest_stanza(self, isodir): - memtest = glob.glob(self._instroot + "/boot/memtest86*") - if not memtest: - return "" - - shutil.copyfile(memtest[0], isodir + "/isolinux/memtest") - - return """label memtest - menu label Memory Test - kernel memtest -""" - - def __get_local_stanza(self, isodir): - return """label local - menu label Boot from local drive - localboot 0xffff -""" - - def _configure_syslinux_bootloader(self, isodir): - """configure the boot loader""" - fs_related.makedirs(isodir + "/isolinux") - - menu = self.__find_syslinux_menu() - - self.__copy_syslinux_files(isodir, menu, - self.__find_syslinux_mboot()) - - background = "" - if self.__copy_syslinux_background(isodir + "/isolinux/splash.jpg"): - background = "menu background splash.jpg" - - cfg = self.__get_basic_syslinux_config(menu = menu, - background = background, - name = self.name, - timeout = self._timeout * 10, - distroname = self.distro_name) - - cfg += self.__get_image_stanzas(isodir) - cfg += self.__get_memtest_stanza(isodir) - cfg += self.__get_local_stanza(isodir) - cfg += self._get_isolinux_stanzas(isodir) - - cfgf = open(isodir + "/isolinux/isolinux.cfg", "w") - cfgf.write(cfg) - cfgf.close() - - def __copy_efi_files(self, isodir): - if not os.path.exists(self._instroot + "/boot/efi/EFI/redhat/grub.efi"): - return False - shutil.copy(self._instroot + "/boot/efi/EFI/redhat/grub.efi", - isodir + "/EFI/boot/grub.efi") - shutil.copy(self._instroot + "/boot/grub/splash.xpm.gz", - isodir + "/EFI/boot/splash.xpm.gz") - - return True - - def __get_basic_efi_config(self, **args): - return """ -default=0 -splashimage=/EFI/boot/splash.xpm.gz -timeout %(timeout)d -hiddenmenu - -""" %args - - def __get_efi_image_stanza(self, **args): - return """title %(long)s - kernel /EFI/boot/vmlinuz%(index)s root=CDLABEL=%(fslabel)s rootfstype=iso9660 %(liveargs)s %(extra)s - initrd /EFI/boot/initrd%(index)s.img -""" %args - - def __get_efi_image_stanzas(self, isodir, name): - # FIXME: this only supports one kernel right now... - - kernel_options = self._get_kernel_options() - checkisomd5 = self._has_checkisomd5() - - cfg = "" - - for index in range(0, 9): - # we don't support xen kernels - if os.path.exists("%s/EFI/boot/xen%d.gz" %(isodir, index)): - continue - cfg += self.__get_efi_image_stanza(fslabel = self.fslabel, - liveargs = kernel_options, - long = name, - extra = "", index = index) - if checkisomd5: - cfg += self.__get_efi_image_stanza( - fslabel = self.fslabel, - liveargs = kernel_options, - long = "Verify and Boot " + name, - extra = "check", - index = index) - break - - return cfg - - def _configure_efi_bootloader(self, isodir): - """Set up the configuration for an EFI bootloader""" - fs_related.makedirs(isodir + "/EFI/boot") - - if not self.__copy_efi_files(isodir): - shutil.rmtree(isodir + "/EFI") - return - - for f in os.listdir(isodir + "/isolinux"): - os.link("%s/isolinux/%s" %(isodir, f), - "%s/EFI/boot/%s" %(isodir, f)) - - - cfg = self.__get_basic_efi_config(name = self.name, - timeout = self._timeout) - cfg += self.__get_efi_image_stanzas(isodir, self.name) - - cfgf = open(isodir + "/EFI/boot/grub.conf", "w") - cfgf.write(cfg) - cfgf.close() - - # first gen mactel machines get the bootloader name wrong apparently - if rpmmisc.getBaseArch() == "i386": - os.link(isodir + "/EFI/boot/grub.efi", - isodir + "/EFI/boot/boot.efi") - os.link(isodir + "/EFI/boot/grub.conf", - isodir + "/EFI/boot/boot.conf") - - # for most things, we want them named boot$efiarch - efiarch = {"i386": "ia32", "x86_64": "x64"} - efiname = efiarch[rpmmisc.getBaseArch()] - os.rename(isodir + "/EFI/boot/grub.efi", - isodir + "/EFI/boot/boot%s.efi" %(efiname,)) - os.link(isodir + "/EFI/boot/grub.conf", - isodir + "/EFI/boot/boot%s.conf" %(efiname,)) - - - def _configure_bootloader(self, isodir): - self._configure_syslinux_bootloader(isodir) - self._configure_efi_bootloader(isodir) - -arch = "i386" -if arch in ("i386", "x86_64"): - LiveCDImageCreator = x86LiveImageCreator -elif arch.startswith("arm"): - LiveCDImageCreator = LiveImageCreatorBase -else: - raise CreatorError("Architecture not supported!") diff --git a/scripts/lib/mic/imager/liveusb.py b/scripts/lib/mic/imager/liveusb.py deleted file mode 100644 index a909928a4c..0000000000 --- a/scripts/lib/mic/imager/liveusb.py +++ /dev/null @@ -1,308 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os -import shutil -import re - -from mic import msger -from mic.utils import misc, fs_related, runner -from mic.utils.errors import CreatorError, MountError -from mic.utils.partitionedfs import PartitionedMount -from mic.imager.livecd import LiveCDImageCreator - - -class LiveUSBImageCreator(LiveCDImageCreator): - def __init__(self, *args): - LiveCDImageCreator.__init__(self, *args) - - self._dep_checks.extend(["kpartx", "parted"]) - - # remove dependency of genisoimage in parent class - if "genisoimage" in self._dep_checks: - self._dep_checks.remove("genisoimage") - - def _create_usbimg(self, isodir): - overlaysizemb = 64 #default - #skipcompress = self.skip_compression? - fstype = "vfat" - homesizemb=0 - swapsizemb=0 - homefile="home.img" - plussize=128 - kernelargs=None - - if fstype == 'vfat': - if overlaysizemb > 2047: - raise CreatorError("Can't have an overlay of 2048MB or " - "greater on VFAT") - - if homesizemb > 2047: - raise CreatorError("Can't have an home overlay of 2048MB or " - "greater on VFAT") - - if swapsizemb > 2047: - raise CreatorError("Can't have an swap overlay of 2048MB or " - "greater on VFAT") - - livesize = misc.get_file_size(isodir + "/LiveOS") - - usbimgsize = (overlaysizemb + \ - homesizemb + \ - swapsizemb + \ - livesize + \ - plussize) * 1024L * 1024L - - disk = fs_related.SparseLoopbackDisk("%s/%s.usbimg" \ - % (self._outdir, self.name), - usbimgsize) - usbmnt = self._mkdtemp("usb-mnt") - usbloop = PartitionedMount(usbmnt) - usbloop.add_disk('/dev/sdb', disk) - - usbloop.add_partition(usbimgsize/1024/1024, - "/dev/sdb", - "/", - fstype, - boot=True) - - usbloop.mount() - - try: - fs_related.makedirs(usbmnt + "/LiveOS") - - if os.path.exists(isodir + "/LiveOS/squashfs.img"): - shutil.copyfile(isodir + "/LiveOS/squashfs.img", - usbmnt + "/LiveOS/squashfs.img") - else: - fs_related.mksquashfs(os.path.dirname(self._image), - usbmnt + "/LiveOS/squashfs.img") - - if os.path.exists(isodir + "/LiveOS/osmin.img"): - shutil.copyfile(isodir + "/LiveOS/osmin.img", - usbmnt + "/LiveOS/osmin.img") - - if fstype == "vfat" or fstype == "msdos": - uuid = usbloop.partitions[0]['mount'].uuid - label = usbloop.partitions[0]['mount'].fslabel - usblabel = "UUID=%s-%s" % (uuid[0:4], uuid[4:8]) - overlaysuffix = "-%s-%s-%s" % (label, uuid[0:4], uuid[4:8]) - else: - diskmount = usbloop.partitions[0]['mount'] - usblabel = "UUID=%s" % diskmount.uuid - overlaysuffix = "-%s-%s" % (diskmount.fslabel, diskmount.uuid) - - args = ['cp', "-Rf", isodir + "/isolinux", usbmnt + "/syslinux"] - rc = runner.show(args) - if rc: - raise CreatorError("Can't copy isolinux directory %s" \ - % (isodir + "/isolinux/*")) - - if os.path.isfile("/usr/share/syslinux/isolinux.bin"): - syslinux_path = "/usr/share/syslinux" - elif os.path.isfile("/usr/lib/syslinux/isolinux.bin"): - syslinux_path = "/usr/lib/syslinux" - else: - raise CreatorError("syslinux not installed : " - "cannot find syslinux installation path") - - for f in ("isolinux.bin", "vesamenu.c32"): - path = os.path.join(syslinux_path, f) - if os.path.isfile(path): - args = ['cp', path, usbmnt + "/syslinux/"] - rc = runner.show(args) - if rc: - raise CreatorError("Can't copy syslinux file " + path) - else: - raise CreatorError("syslinux not installed: " - "syslinux file %s not found" % path) - - fd = open(isodir + "/isolinux/isolinux.cfg", "r") - text = fd.read() - fd.close() - pattern = re.compile('CDLABEL=[^ ]*') - text = pattern.sub(usblabel, text) - pattern = re.compile('rootfstype=[^ ]*') - text = pattern.sub("rootfstype=" + fstype, text) - if kernelargs: - text = text.replace("rd.live.image", "rd.live.image " + kernelargs) - - if overlaysizemb > 0: - msger.info("Initializing persistent overlay file") - overfile = "overlay" + overlaysuffix - if fstype == "vfat": - args = ['dd', - "if=/dev/zero", - "of=" + usbmnt + "/LiveOS/" + overfile, - "count=%d" % overlaysizemb, - "bs=1M"] - else: - args = ['dd', - "if=/dev/null", - "of=" + usbmnt + "/LiveOS/" + overfile, - "count=1", - "bs=1M", - "seek=%d" % overlaysizemb] - rc = runner.show(args) - if rc: - raise CreatorError("Can't create overlay file") - text = text.replace("rd.live.image", "rd.live.image rd.live.overlay=" + usblabel) - text = text.replace(" ro ", " rw ") - - if swapsizemb > 0: - msger.info("Initializing swap file") - swapfile = usbmnt + "/LiveOS/" + "swap.img" - args = ['dd', - "if=/dev/zero", - "of=" + swapfile, - "count=%d" % swapsizemb, - "bs=1M"] - rc = runner.show(args) - if rc: - raise CreatorError("Can't create swap file") - args = ["mkswap", "-f", swapfile] - rc = runner.show(args) - if rc: - raise CreatorError("Can't mkswap on swap file") - - if homesizemb > 0: - msger.info("Initializing persistent /home") - homefile = usbmnt + "/LiveOS/" + homefile - if fstype == "vfat": - args = ['dd', - "if=/dev/zero", - "of=" + homefile, - "count=%d" % homesizemb, - "bs=1M"] - else: - args = ['dd', - "if=/dev/null", - "of=" + homefile, - "count=1", - "bs=1M", - "seek=%d" % homesizemb] - rc = runner.show(args) - if rc: - raise CreatorError("Can't create home file") - - mkfscmd = fs_related.find_binary_path("/sbin/mkfs." + fstype) - if fstype == "ext2" or fstype == "ext3": - args = [mkfscmd, "-F", "-j", homefile] - else: - args = [mkfscmd, homefile] - rc = runner.show(args) - if rc: - raise CreatorError("Can't mke2fs home file") - if fstype == "ext2" or fstype == "ext3": - tune2fs = fs_related.find_binary_path("tune2fs") - args = [tune2fs, - "-c0", - "-i0", - "-ouser_xattr,acl", - homefile] - rc = runner.show(args) - if rc: - raise CreatorError("Can't tune2fs home file") - - if fstype == "vfat" or fstype == "msdos": - syslinuxcmd = fs_related.find_binary_path("syslinux") - syslinuxcfg = usbmnt + "/syslinux/syslinux.cfg" - args = [syslinuxcmd, - "-d", - "syslinux", - usbloop.partitions[0]["device"]] - - elif fstype == "ext2" or fstype == "ext3": - extlinuxcmd = fs_related.find_binary_path("extlinux") - syslinuxcfg = usbmnt + "/syslinux/extlinux.conf" - args = [extlinuxcmd, - "-i", - usbmnt + "/syslinux"] - - else: - raise CreatorError("Invalid file system type: %s" % (fstype)) - - os.unlink(usbmnt + "/syslinux/isolinux.cfg") - fd = open(syslinuxcfg, "w") - fd.write(text) - fd.close() - rc = runner.show(args) - if rc: - raise CreatorError("Can't install boot loader.") - - finally: - usbloop.unmount() - usbloop.cleanup() - - # Need to do this after image is unmounted and device mapper is closed - msger.info("set MBR") - mbrfile = "/usr/lib/syslinux/mbr.bin" - if not os.path.exists(mbrfile): - mbrfile = "/usr/share/syslinux/mbr.bin" - if not os.path.exists(mbrfile): - raise CreatorError("mbr.bin file didn't exist.") - mbrsize = os.path.getsize(mbrfile) - outimg = "%s/%s.usbimg" % (self._outdir, self.name) - - args = ['dd', - "if=" + mbrfile, - "of=" + outimg, - "seek=0", - "conv=notrunc", - "bs=1", - "count=%d" % (mbrsize)] - rc = runner.show(args) - if rc: - raise CreatorError("Can't set MBR.") - - def _stage_final_image(self): - try: - isodir = self._get_isodir() - fs_related.makedirs(isodir + "/LiveOS") - - minimal_size = self._resparse() - - if not self.skip_minimize: - fs_related.create_image_minimizer(isodir + "/LiveOS/osmin.img", - self._image, - minimal_size) - - if self.skip_compression: - shutil.move(self._image, - isodir + "/LiveOS/ext3fs.img") - else: - fs_related.makedirs(os.path.join( - os.path.dirname(self._image), - "LiveOS")) - shutil.move(self._image, - os.path.join(os.path.dirname(self._image), - "LiveOS", "ext3fs.img")) - fs_related.mksquashfs(os.path.dirname(self._image), - isodir + "/LiveOS/squashfs.img") - - self._create_usbimg(isodir) - - if self.pack_to: - usbimg = os.path.join(self._outdir, self.name + ".usbimg") - packimg = os.path.join(self._outdir, self.pack_to) - misc.packing(packimg, usbimg) - os.unlink(usbimg) - - finally: - shutil.rmtree(isodir, ignore_errors = True) - self._set_isodir(None) - diff --git a/scripts/lib/mic/imager/loop.py b/scripts/lib/mic/imager/loop.py deleted file mode 100644 index 4d05ef271d..0000000000 --- a/scripts/lib/mic/imager/loop.py +++ /dev/null @@ -1,418 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os -import glob -import shutil - -from mic import kickstart, msger -from mic.utils.errors import CreatorError, MountError -from mic.utils import misc, runner, fs_related as fs -from mic.imager.baseimager import BaseImageCreator - - -# The maximum string length supported for LoopImageCreator.fslabel -FSLABEL_MAXLEN = 32 - - -def save_mountpoints(fpath, loops, arch = None): - """Save mount points mapping to file - - :fpath, the xml file to store partition info - :loops, dict of partition info - :arch, image arch - """ - - if not fpath or not loops: - return - - from xml.dom import minidom - doc = minidom.Document() - imgroot = doc.createElement("image") - doc.appendChild(imgroot) - if arch: - imgroot.setAttribute('arch', arch) - for loop in loops: - part = doc.createElement("partition") - imgroot.appendChild(part) - for (key, val) in loop.items(): - if isinstance(val, fs.Mount): - continue - part.setAttribute(key, str(val)) - - with open(fpath, 'w') as wf: - wf.write(doc.toprettyxml(indent=' ')) - - return - -def load_mountpoints(fpath): - """Load mount points mapping from file - - :fpath, file path to load - """ - - if not fpath: - return - - from xml.dom import minidom - mount_maps = [] - with open(fpath, 'r') as rf: - dom = minidom.parse(rf) - imgroot = dom.documentElement - for part in imgroot.getElementsByTagName("partition"): - p = dict(part.attributes.items()) - - try: - mp = (p['mountpoint'], p['label'], p['name'], - int(p['size']), p['fstype']) - except KeyError: - msger.warning("Wrong format line in file: %s" % fpath) - except ValueError: - msger.warning("Invalid size '%s' in file: %s" % (p['size'], fpath)) - else: - mount_maps.append(mp) - - return mount_maps - -class LoopImageCreator(BaseImageCreator): - """Installs a system into a loopback-mountable filesystem image. - - LoopImageCreator is a straightforward ImageCreator subclass; the system - is installed into an ext3 filesystem on a sparse file which can be - subsequently loopback-mounted. - - When specifying multiple partitions in kickstart file, each partition - will be created as a separated loop image. - """ - - def __init__(self, creatoropts=None, pkgmgr=None, - compress_image=None, - shrink_image=False): - """Initialize a LoopImageCreator instance. - - This method takes the same arguments as ImageCreator.__init__() - with the addition of: - - fslabel -- A string used as a label for any filesystems created. - """ - - BaseImageCreator.__init__(self, creatoropts, pkgmgr) - - self.compress_image = compress_image - self.shrink_image = shrink_image - - self.__fslabel = None - self.fslabel = self.name - - self.__blocksize = 4096 - if self.ks: - self.__fstype = kickstart.get_image_fstype(self.ks, - "ext3") - self.__fsopts = kickstart.get_image_fsopts(self.ks, - "defaults,noatime") - - allloops = [] - for part in sorted(kickstart.get_partitions(self.ks), - key=lambda p: p.mountpoint): - if part.fstype == "swap": - continue - - label = part.label - mp = part.mountpoint - if mp == '/': - # the base image - if not label: - label = self.name - else: - mp = mp.rstrip('/') - if not label: - msger.warning('no "label" specified for loop img at %s' - ', use the mountpoint as the name' % mp) - label = mp.split('/')[-1] - - imgname = misc.strip_end(label, '.img') + '.img' - allloops.append({ - 'mountpoint': mp, - 'label': label, - 'name': imgname, - 'size': part.size or 4096L * 1024 * 1024, - 'fstype': part.fstype or 'ext3', - 'extopts': part.extopts or None, - 'loop': None, # to be created in _mount_instroot - }) - self._instloops = allloops - - else: - self.__fstype = None - self.__fsopts = None - self._instloops = [] - - self.__imgdir = None - - if self.ks: - self.__image_size = kickstart.get_image_size(self.ks, - 4096L * 1024 * 1024) - else: - self.__image_size = 0 - - self._img_name = self.name + ".img" - - def get_image_names(self): - if not self._instloops: - return None - - return [lo['name'] for lo in self._instloops] - - def _set_fstype(self, fstype): - self.__fstype = fstype - - def _set_image_size(self, imgsize): - self.__image_size = imgsize - - - # - # Properties - # - def __get_fslabel(self): - if self.__fslabel is None: - return self.name - else: - return self.__fslabel - def __set_fslabel(self, val): - if val is None: - self.__fslabel = None - else: - self.__fslabel = val[:FSLABEL_MAXLEN] - #A string used to label any filesystems created. - # - #Some filesystems impose a constraint on the maximum allowed size of the - #filesystem label. In the case of ext3 it's 16 characters, but in the case - #of ISO9660 it's 32 characters. - # - #mke2fs silently truncates the label, but mkisofs aborts if the label is - #too long. So, for convenience sake, any string assigned to this attribute - #is silently truncated to FSLABEL_MAXLEN (32) characters. - fslabel = property(__get_fslabel, __set_fslabel) - - def __get_image(self): - if self.__imgdir is None: - raise CreatorError("_image is not valid before calling mount()") - return os.path.join(self.__imgdir, self._img_name) - #The location of the image file. - # - #This is the path to the filesystem image. Subclasses may use this path - #in order to package the image in _stage_final_image(). - # - #Note, this directory does not exist before ImageCreator.mount() is called. - # - #Note also, this is a read-only attribute. - _image = property(__get_image) - - def __get_blocksize(self): - return self.__blocksize - def __set_blocksize(self, val): - if self._instloops: - raise CreatorError("_blocksize must be set before calling mount()") - try: - self.__blocksize = int(val) - except ValueError: - raise CreatorError("'%s' is not a valid integer value " - "for _blocksize" % val) - #The block size used by the image's filesystem. - # - #This is the block size used when creating the filesystem image. Subclasses - #may change this if they wish to use something other than a 4k block size. - # - #Note, this attribute may only be set before calling mount(). - _blocksize = property(__get_blocksize, __set_blocksize) - - def __get_fstype(self): - return self.__fstype - def __set_fstype(self, val): - if val != "ext2" and val != "ext3": - raise CreatorError("Unknown _fstype '%s' supplied" % val) - self.__fstype = val - #The type of filesystem used for the image. - # - #This is the filesystem type used when creating the filesystem image. - #Subclasses may change this if they wish to use something other ext3. - # - #Note, only ext2 and ext3 are currently supported. - # - #Note also, this attribute may only be set before calling mount(). - _fstype = property(__get_fstype, __set_fstype) - - def __get_fsopts(self): - return self.__fsopts - def __set_fsopts(self, val): - self.__fsopts = val - #Mount options of filesystem used for the image. - # - #This can be specified by --fsoptions="xxx,yyy" in part command in - #kickstart file. - _fsopts = property(__get_fsopts, __set_fsopts) - - - # - # Helpers for subclasses - # - def _resparse(self, size=None): - """Rebuild the filesystem image to be as sparse as possible. - - This method should be used by subclasses when staging the final image - in order to reduce the actual space taken up by the sparse image file - to be as little as possible. - - This is done by resizing the filesystem to the minimal size (thereby - eliminating any space taken up by deleted files) and then resizing it - back to the supplied size. - - size -- the size in, in bytes, which the filesystem image should be - resized to after it has been minimized; this defaults to None, - causing the original size specified by the kickstart file to - be used (or 4GiB if not specified in the kickstart). - """ - minsize = 0 - for item in self._instloops: - if item['name'] == self._img_name: - minsize = item['loop'].resparse(size) - else: - item['loop'].resparse(size) - - return minsize - - def _base_on(self, base_on=None): - if base_on and self._image != base_on: - shutil.copyfile(base_on, self._image) - - def _check_imgdir(self): - if self.__imgdir is None: - self.__imgdir = self._mkdtemp() - - - # - # Actual implementation - # - def _mount_instroot(self, base_on=None): - - if base_on and os.path.isfile(base_on): - self.__imgdir = os.path.dirname(base_on) - imgname = os.path.basename(base_on) - self._base_on(base_on) - self._set_image_size(misc.get_file_size(self._image)) - - # here, self._instloops must be [] - self._instloops.append({ - "mountpoint": "/", - "label": self.name, - "name": imgname, - "size": self.__image_size or 4096L, - "fstype": self.__fstype or "ext3", - "extopts": None, - "loop": None - }) - - self._check_imgdir() - - for loop in self._instloops: - fstype = loop['fstype'] - mp = os.path.join(self._instroot, loop['mountpoint'].lstrip('/')) - size = loop['size'] * 1024L * 1024L - imgname = loop['name'] - - if fstype in ("ext2", "ext3", "ext4"): - MyDiskMount = fs.ExtDiskMount - elif fstype == "btrfs": - MyDiskMount = fs.BtrfsDiskMount - elif fstype in ("vfat", "msdos"): - MyDiskMount = fs.VfatDiskMount - else: - msger.error('Cannot support fstype: %s' % fstype) - - loop['loop'] = MyDiskMount(fs.SparseLoopbackDisk( - os.path.join(self.__imgdir, imgname), - size), - mp, - fstype, - self._blocksize, - loop['label']) - - if fstype in ("ext2", "ext3", "ext4"): - loop['loop'].extopts = loop['extopts'] - - try: - msger.verbose('Mounting image "%s" on "%s"' % (imgname, mp)) - fs.makedirs(mp) - loop['loop'].mount() - except MountError, e: - raise - - def _unmount_instroot(self): - for item in reversed(self._instloops): - try: - item['loop'].cleanup() - except: - pass - - def _stage_final_image(self): - - if self.pack_to or self.shrink_image: - self._resparse(0) - else: - self._resparse() - - for item in self._instloops: - imgfile = os.path.join(self.__imgdir, item['name']) - if item['fstype'] == "ext4": - runner.show('/sbin/tune2fs -O ^huge_file,extents,uninit_bg %s ' - % imgfile) - if self.compress_image: - misc.compressing(imgfile, self.compress_image) - - if not self.pack_to: - for item in os.listdir(self.__imgdir): - shutil.move(os.path.join(self.__imgdir, item), - os.path.join(self._outdir, item)) - else: - msger.info("Pack all loop images together to %s" % self.pack_to) - dstfile = os.path.join(self._outdir, self.pack_to) - misc.packing(dstfile, self.__imgdir) - - if self.pack_to: - mountfp_xml = os.path.splitext(self.pack_to)[0] - mountfp_xml = misc.strip_end(mountfp_xml, '.tar') + ".xml" - else: - mountfp_xml = self.name + ".xml" - # save mount points mapping file to xml - save_mountpoints(os.path.join(self._outdir, mountfp_xml), - self._instloops, - self.target_arch) - - def copy_attachment(self): - if not hasattr(self, '_attachment') or not self._attachment: - return - - self._check_imgdir() - - msger.info("Copying attachment files...") - for item in self._attachment: - if not os.path.exists(item): - continue - dpath = os.path.join(self.__imgdir, os.path.basename(item)) - msger.verbose("Copy attachment %s to %s" % (item, dpath)) - shutil.copy(item, dpath) - diff --git a/scripts/lib/mic/imager/raw.py b/scripts/lib/mic/imager/raw.py deleted file mode 100644 index 838191a6f1..0000000000 --- a/scripts/lib/mic/imager/raw.py +++ /dev/null @@ -1,501 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os -import stat -import shutil - -from mic import kickstart, msger -from mic.utils import fs_related, runner, misc -from mic.utils.partitionedfs import PartitionedMount -from mic.utils.errors import CreatorError, MountError -from mic.imager.baseimager import BaseImageCreator - - -class RawImageCreator(BaseImageCreator): - """Installs a system into a file containing a partitioned disk image. - - ApplianceImageCreator is an advanced ImageCreator subclass; a sparse file - is formatted with a partition table, each partition loopback mounted - and the system installed into an virtual disk. The disk image can - subsequently be booted in a virtual machine or accessed with kpartx - """ - - def __init__(self, creatoropts=None, pkgmgr=None, compress_image=None, generate_bmap=None, fstab_entry="uuid"): - """Initialize a ApplianceImageCreator instance. - - This method takes the same arguments as ImageCreator.__init__() - """ - BaseImageCreator.__init__(self, creatoropts, pkgmgr) - - self.__instloop = None - self.__imgdir = None - self.__disks = {} - self.__disk_format = "raw" - self._disk_names = [] - self._ptable_format = self.ks.handler.bootloader.ptable - self.vmem = 512 - self.vcpu = 1 - self.checksum = False - self.use_uuid = fstab_entry == "uuid" - self.appliance_version = None - self.appliance_release = None - self.compress_image = compress_image - self.bmap_needed = generate_bmap - self._need_extlinux = not kickstart.use_installerfw(self.ks, "extlinux") - #self.getsource = False - #self.listpkg = False - - self._dep_checks.extend(["sync", "kpartx", "parted"]) - if self._need_extlinux: - self._dep_checks.extend(["extlinux"]) - - def configure(self, repodata = None): - import subprocess - def chroot(): - os.chroot(self._instroot) - os.chdir("/") - - if os.path.exists(self._instroot + "/usr/bin/Xorg"): - subprocess.call(["/bin/chmod", "u+s", "/usr/bin/Xorg"], - preexec_fn = chroot) - - BaseImageCreator.configure(self, repodata) - - def _get_fstab(self): - if kickstart.use_installerfw(self.ks, "fstab"): - # The fstab file will be generated by installer framework scripts - # instead. - return None - - s = "" - for mp in self.__instloop.mountOrder: - p = None - for p1 in self.__instloop.partitions: - if p1['mountpoint'] == mp: - p = p1 - break - - if self.use_uuid and p['uuid']: - device = "UUID=%s" % p['uuid'] - else: - device = "/dev/%s%-d" % (p['disk_name'], p['num']) - - s += "%(device)s %(mountpoint)s %(fstype)s %(fsopts)s 0 0\n" % { - 'device': device, - 'mountpoint': p['mountpoint'], - 'fstype': p['fstype'], - 'fsopts': "defaults,noatime" if not p['fsopts'] else p['fsopts']} - - if p['mountpoint'] == "/": - for subvol in self.__instloop.subvolumes: - if subvol['mountpoint'] == "/": - continue - s += "%(device)s %(mountpoint)s %(fstype)s %(fsopts)s 0 0\n" % { - 'device': "/dev/%s%-d" % (p['disk_name'], p['num']), - 'mountpoint': subvol['mountpoint'], - 'fstype': p['fstype'], - 'fsopts': "defaults,noatime" if not subvol['fsopts'] else subvol['fsopts']} - - s += "devpts /dev/pts devpts gid=5,mode=620 0 0\n" - s += "tmpfs /dev/shm tmpfs defaults 0 0\n" - s += "proc /proc proc defaults 0 0\n" - s += "sysfs /sys sysfs defaults 0 0\n" - return s - - def _create_mkinitrd_config(self): - """write to tell which modules to be included in initrd""" - - mkinitrd = "" - mkinitrd += "PROBE=\"no\"\n" - mkinitrd += "MODULES+=\"ext3 ata_piix sd_mod libata scsi_mod\"\n" - mkinitrd += "rootfs=\"ext3\"\n" - mkinitrd += "rootopts=\"defaults\"\n" - - msger.debug("Writing mkinitrd config %s/etc/sysconfig/mkinitrd" \ - % self._instroot) - os.makedirs(self._instroot + "/etc/sysconfig/",mode=644) - cfg = open(self._instroot + "/etc/sysconfig/mkinitrd", "w") - cfg.write(mkinitrd) - cfg.close() - - def _get_parts(self): - if not self.ks: - raise CreatorError("Failed to get partition info, " - "please check your kickstart setting.") - - # Set a default partition if no partition is given out - if not self.ks.handler.partition.partitions: - partstr = "part / --size 1900 --ondisk sda --fstype=ext3" - args = partstr.split() - pd = self.ks.handler.partition.parse(args[1:]) - if pd not in self.ks.handler.partition.partitions: - self.ks.handler.partition.partitions.append(pd) - - # partitions list from kickstart file - return kickstart.get_partitions(self.ks) - - def get_disk_names(self): - """ Returns a list of physical target disk names (e.g., 'sdb') which - will be created. """ - - if self._disk_names: - return self._disk_names - - #get partition info from ks handler - parts = self._get_parts() - - for i in range(len(parts)): - if parts[i].disk: - disk_name = parts[i].disk - else: - raise CreatorError("Failed to create disks, no --ondisk " - "specified in partition line of ks file") - - if parts[i].mountpoint and not parts[i].fstype: - raise CreatorError("Failed to create disks, no --fstype " - "specified for partition with mountpoint " - "'%s' in the ks file") - - self._disk_names.append(disk_name) - - return self._disk_names - - def _full_name(self, name, extention): - """ Construct full file name for a file we generate. """ - return "%s-%s.%s" % (self.name, name, extention) - - def _full_path(self, path, name, extention): - """ Construct full file path to a file we generate. """ - return os.path.join(path, self._full_name(name, extention)) - - # - # Actual implemention - # - def _mount_instroot(self, base_on = None): - parts = self._get_parts() - self.__instloop = PartitionedMount(self._instroot) - - for p in parts: - self.__instloop.add_partition(int(p.size), - p.disk, - p.mountpoint, - p.fstype, - p.label, - fsopts = p.fsopts, - boot = p.active, - align = p.align, - part_type = p.part_type) - - self.__instloop.layout_partitions(self._ptable_format) - - # Create the disks - self.__imgdir = self._mkdtemp() - for disk_name, disk in self.__instloop.disks.items(): - full_path = self._full_path(self.__imgdir, disk_name, "raw") - msger.debug("Adding disk %s as %s with size %s bytes" \ - % (disk_name, full_path, disk['min_size'])) - - disk_obj = fs_related.SparseLoopbackDisk(full_path, - disk['min_size']) - self.__disks[disk_name] = disk_obj - self.__instloop.add_disk(disk_name, disk_obj) - - self.__instloop.mount() - self._create_mkinitrd_config() - - def _get_required_packages(self): - required_packages = BaseImageCreator._get_required_packages(self) - if self._need_extlinux: - if not self.target_arch or not self.target_arch.startswith("arm"): - required_packages += ["syslinux", "syslinux-extlinux"] - return required_packages - - def _get_excluded_packages(self): - return BaseImageCreator._get_excluded_packages(self) - - def _get_syslinux_boot_config(self): - rootdev = None - root_part_uuid = None - for p in self.__instloop.partitions: - if p['mountpoint'] == "/": - rootdev = "/dev/%s%-d" % (p['disk_name'], p['num']) - root_part_uuid = p['partuuid'] - - return (rootdev, root_part_uuid) - - def _create_syslinux_config(self): - - splash = os.path.join(self._instroot, "boot/extlinux") - if os.path.exists(splash): - splashline = "menu background splash.jpg" - else: - splashline = "" - - (rootdev, root_part_uuid) = self._get_syslinux_boot_config() - options = self.ks.handler.bootloader.appendLine - - #XXX don't hardcode default kernel - see livecd code - syslinux_conf = "" - syslinux_conf += "prompt 0\n" - syslinux_conf += "timeout 1\n" - syslinux_conf += "\n" - syslinux_conf += "default vesamenu.c32\n" - syslinux_conf += "menu autoboot Starting %s...\n" % self.distro_name - syslinux_conf += "menu hidden\n" - syslinux_conf += "\n" - syslinux_conf += "%s\n" % splashline - syslinux_conf += "menu title Welcome to %s!\n" % self.distro_name - syslinux_conf += "menu color border 0 #ffffffff #00000000\n" - syslinux_conf += "menu color sel 7 #ffffffff #ff000000\n" - syslinux_conf += "menu color title 0 #ffffffff #00000000\n" - syslinux_conf += "menu color tabmsg 0 #ffffffff #00000000\n" - syslinux_conf += "menu color unsel 0 #ffffffff #00000000\n" - syslinux_conf += "menu color hotsel 0 #ff000000 #ffffffff\n" - syslinux_conf += "menu color hotkey 7 #ffffffff #ff000000\n" - syslinux_conf += "menu color timeout_msg 0 #ffffffff #00000000\n" - syslinux_conf += "menu color timeout 0 #ffffffff #00000000\n" - syslinux_conf += "menu color cmdline 0 #ffffffff #00000000\n" - - versions = [] - kernels = self._get_kernel_versions() - symkern = "%s/boot/vmlinuz" % self._instroot - - if os.path.lexists(symkern): - v = os.path.realpath(symkern).replace('%s-' % symkern, "") - syslinux_conf += "label %s\n" % self.distro_name.lower() - syslinux_conf += "\tmenu label %s (%s)\n" % (self.distro_name, v) - syslinux_conf += "\tlinux ../vmlinuz\n" - if self._ptable_format == 'msdos': - rootstr = rootdev - else: - if not root_part_uuid: - raise MountError("Cannot find the root GPT partition UUID") - rootstr = "PARTUUID=%s" % root_part_uuid - syslinux_conf += "\tappend ro root=%s %s\n" % (rootstr, options) - syslinux_conf += "\tmenu default\n" - else: - for kernel in kernels: - for version in kernels[kernel]: - versions.append(version) - - footlabel = 0 - for v in versions: - syslinux_conf += "label %s%d\n" \ - % (self.distro_name.lower(), footlabel) - syslinux_conf += "\tmenu label %s (%s)\n" % (self.distro_name, v) - syslinux_conf += "\tlinux ../vmlinuz-%s\n" % v - syslinux_conf += "\tappend ro root=%s %s\n" \ - % (rootdev, options) - if footlabel == 0: - syslinux_conf += "\tmenu default\n" - footlabel += 1; - - msger.debug("Writing syslinux config %s/boot/extlinux/extlinux.conf" \ - % self._instroot) - cfg = open(self._instroot + "/boot/extlinux/extlinux.conf", "w") - cfg.write(syslinux_conf) - cfg.close() - - def _install_syslinux(self): - for name in self.__disks.keys(): - loopdev = self.__disks[name].device - - # Set MBR - mbrfile = "%s/usr/share/syslinux/" % self._instroot - if self._ptable_format == 'gpt': - mbrfile += "gptmbr.bin" - else: - mbrfile += "mbr.bin" - - msger.debug("Installing syslinux bootloader '%s' to %s" % \ - (mbrfile, loopdev)) - - mbrsize = os.stat(mbrfile)[stat.ST_SIZE] - rc = runner.show(['dd', 'if=%s' % mbrfile, 'of=' + loopdev]) - if rc != 0: - raise MountError("Unable to set MBR to %s" % loopdev) - - - # Ensure all data is flushed to disk before doing syslinux install - runner.quiet('sync') - - fullpathsyslinux = fs_related.find_binary_path("extlinux") - rc = runner.show([fullpathsyslinux, - "-i", - "%s/boot/extlinux" % self._instroot]) - if rc != 0: - raise MountError("Unable to install syslinux bootloader to %s" \ - % loopdev) - - def _create_bootconfig(self): - #If syslinux is available do the required configurations. - if self._need_extlinux \ - and os.path.exists("%s/usr/share/syslinux/" % (self._instroot)) \ - and os.path.exists("%s/boot/extlinux/" % (self._instroot)): - self._create_syslinux_config() - self._install_syslinux() - - def _unmount_instroot(self): - if not self.__instloop is None: - try: - self.__instloop.cleanup() - except MountError, err: - msger.warning("%s" % err) - - def _resparse(self, size = None): - return self.__instloop.resparse(size) - - def _get_post_scripts_env(self, in_chroot): - env = BaseImageCreator._get_post_scripts_env(self, in_chroot) - - # Export the file-system UUIDs and partition UUIDs (AKA PARTUUIDs) - for p in self.__instloop.partitions: - env.update(self._set_part_env(p['ks_pnum'], "UUID", p['uuid'])) - env.update(self._set_part_env(p['ks_pnum'], "PARTUUID", p['partuuid'])) - - return env - - def _stage_final_image(self): - """Stage the final system image in _outdir. - write meta data - """ - self._resparse() - - if self.compress_image: - for imgfile in os.listdir(self.__imgdir): - if imgfile.endswith('.raw') or imgfile.endswith('bin'): - imgpath = os.path.join(self.__imgdir, imgfile) - misc.compressing(imgpath, self.compress_image) - - if self.pack_to: - dst = os.path.join(self._outdir, self.pack_to) - msger.info("Pack all raw images to %s" % dst) - misc.packing(dst, self.__imgdir) - else: - msger.debug("moving disks to stage location") - for imgfile in os.listdir(self.__imgdir): - src = os.path.join(self.__imgdir, imgfile) - dst = os.path.join(self._outdir, imgfile) - msger.debug("moving %s to %s" % (src,dst)) - shutil.move(src,dst) - self._write_image_xml() - - def _write_image_xml(self): - imgarch = "i686" - if self.target_arch and self.target_arch.startswith("arm"): - imgarch = "arm" - xml = "<image>\n" - - name_attributes = "" - if self.appliance_version: - name_attributes += " version='%s'" % self.appliance_version - if self.appliance_release: - name_attributes += " release='%s'" % self.appliance_release - xml += " <name%s>%s</name>\n" % (name_attributes, self.name) - xml += " <domain>\n" - # XXX don't hardcode - determine based on the kernel we installed for - # grub baremetal vs xen - xml += " <boot type='hvm'>\n" - xml += " <guest>\n" - xml += " <arch>%s</arch>\n" % imgarch - xml += " </guest>\n" - xml += " <os>\n" - xml += " <loader dev='hd'/>\n" - xml += " </os>\n" - - i = 0 - for name in self.__disks.keys(): - full_name = self._full_name(name, self.__disk_format) - xml += " <drive disk='%s' target='hd%s'/>\n" \ - % (full_name, chr(ord('a') + i)) - i = i + 1 - - xml += " </boot>\n" - xml += " <devices>\n" - xml += " <vcpu>%s</vcpu>\n" % self.vcpu - xml += " <memory>%d</memory>\n" %(self.vmem * 1024) - for network in self.ks.handler.network.network: - xml += " <interface/>\n" - xml += " <graphics/>\n" - xml += " </devices>\n" - xml += " </domain>\n" - xml += " <storage>\n" - - if self.checksum is True: - for name in self.__disks.keys(): - diskpath = self._full_path(self._outdir, name, \ - self.__disk_format) - full_name = self._full_name(name, self.__disk_format) - - msger.debug("Generating disk signature for %s" % full_name) - - xml += " <disk file='%s' use='system' format='%s'>\n" \ - % (full_name, self.__disk_format) - - hashes = misc.calc_hashes(diskpath, ('sha1', 'sha256')) - - xml += " <checksum type='sha1'>%s</checksum>\n" \ - % hashes[0] - xml += " <checksum type='sha256'>%s</checksum>\n" \ - % hashes[1] - xml += " </disk>\n" - else: - for name in self.__disks.keys(): - full_name = self._full_name(name, self.__disk_format) - xml += " <disk file='%s' use='system' format='%s'/>\n" \ - % (full_name, self.__disk_format) - - xml += " </storage>\n" - xml += "</image>\n" - - msger.debug("writing image XML to %s/%s.xml" %(self._outdir, self.name)) - cfg = open("%s/%s.xml" % (self._outdir, self.name), "w") - cfg.write(xml) - cfg.close() - - def generate_bmap(self): - """ Generate block map file for the image. The idea is that while disk - images we generate may be large (e.g., 4GiB), they may actually contain - only little real data, e.g., 512MiB. This data are files, directories, - file-system meta-data, partition table, etc. In other words, when - flashing the image to the target device, you do not have to copy all the - 4GiB of data, you can copy only 512MiB of it, which is 4 times faster. - - This function generates the block map file for an arbitrary image that - mic has generated. The block map file is basically an XML file which - contains a list of blocks which have to be copied to the target device. - The other blocks are not used and there is no need to copy them. """ - - if self.bmap_needed is None: - return - - from mic.utils import BmapCreate - msger.info("Generating the map file(s)") - - for name in self.__disks.keys(): - image = self._full_path(self.__imgdir, name, self.__disk_format) - bmap_file = self._full_path(self._outdir, name, "bmap") - - msger.debug("Generating block map file '%s'" % bmap_file) - - try: - creator = BmapCreate.BmapCreate(image, bmap_file) - creator.generate() - del creator - except BmapCreate.Error as err: - raise CreatorError("Failed to create bmap file: %s" % str(err)) diff --git a/scripts/lib/mic/kickstart/__init__.py b/scripts/lib/mic/kickstart/__init__.py deleted file mode 100644 index 72f3ca6849..0000000000 --- a/scripts/lib/mic/kickstart/__init__.py +++ /dev/null @@ -1,892 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2007 Red Hat, Inc. -# Copyright (c) 2009, 2010, 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os, sys, re -import shutil -import subprocess -import string - -import pykickstart.sections as kssections -import pykickstart.commands as kscommands -import pykickstart.constants as ksconstants -import pykickstart.errors as kserrors -import pykickstart.parser as ksparser -import pykickstart.version as ksversion -from pykickstart.handlers.control import commandMap -from pykickstart.handlers.control import dataMap - -from mic import msger -from mic.utils import errors, misc, runner, fs_related as fs -from custom_commands import desktop, micrepo, wicboot, partition, installerfw - - -AUTH_URL_PTN = r"(?P<scheme>.*)://(?P<username>.*)(:?P<password>.*)?@(?P<url>.*)" - - -class PrepackageSection(kssections.Section): - sectionOpen = "%prepackages" - - def handleLine(self, line): - if not self.handler: - return - - (h, s, t) = line.partition('#') - line = h.rstrip() - - self.handler.prepackages.add([line]) - - def handleHeader(self, lineno, args): - kssections.Section.handleHeader(self, lineno, args) - -class AttachmentSection(kssections.Section): - sectionOpen = "%attachment" - - def handleLine(self, line): - if not self.handler: - return - - (h, s, t) = line.partition('#') - line = h.rstrip() - - self.handler.attachment.add([line]) - - def handleHeader(self, lineno, args): - kssections.Section.handleHeader(self, lineno, args) - -def apply_wrapper(func): - def wrapper(*kargs, **kwargs): - try: - func(*kargs, **kwargs) - except (OSError, IOError, errors.KsError), err: - cfgcls = kargs[0].__class__.__name__ - if msger.ask("Failed to apply %s, skip and continue?" % cfgcls): - msger.warning("%s" % err) - pass - else: - # just throw out the exception - raise - return wrapper - -def read_kickstart(path): - """Parse a kickstart file and return a KickstartParser instance. - - This is a simple utility function which takes a path to a kickstart file, - parses it and returns a pykickstart KickstartParser instance which can - be then passed to an ImageCreator constructor. - - If an error occurs, a CreatorError exception is thrown. - """ - - #version = ksversion.makeVersion() - #ks = ksparser.KickstartParser(version) - - using_version = ksversion.DEVEL - commandMap[using_version]["desktop"] = desktop.Mic_Desktop - commandMap[using_version]["repo"] = micrepo.Mic_Repo - commandMap[using_version]["bootloader"] = wicboot.Wic_Bootloader - commandMap[using_version]["part"] = partition.Wic_Partition - commandMap[using_version]["partition"] = partition.Wic_Partition - commandMap[using_version]["installerfw"] = installerfw.Mic_installerfw - dataMap[using_version]["RepoData"] = micrepo.Mic_RepoData - dataMap[using_version]["PartData"] = partition.Wic_PartData - superclass = ksversion.returnClassForVersion(version=using_version) - - class KSHandlers(superclass): - def __init__(self): - superclass.__init__(self, mapping=commandMap[using_version]) - self.prepackages = ksparser.Packages() - self.attachment = ksparser.Packages() - - ks = ksparser.KickstartParser(KSHandlers(), errorsAreFatal=False) - ks.registerSection(PrepackageSection(ks.handler)) - ks.registerSection(AttachmentSection(ks.handler)) - - try: - ks.readKickstart(path) - except (kserrors.KickstartParseError, kserrors.KickstartError), err: - if msger.ask("Errors occured on kickstart file, skip and continue?"): - msger.warning("%s" % err) - pass - else: - raise errors.KsError("%s" % err) - - return ks - -class KickstartConfig(object): - """A base class for applying kickstart configurations to a system.""" - def __init__(self, instroot): - self.instroot = instroot - - def path(self, subpath): - return self.instroot + subpath - - def _check_sysconfig(self): - if not os.path.exists(self.path("/etc/sysconfig")): - fs.makedirs(self.path("/etc/sysconfig")) - - def chroot(self): - os.chroot(self.instroot) - os.chdir("/") - - def call(self, args): - if not os.path.exists("%s/%s" %(self.instroot, args[0])): - raise errors.KsError("Can't find %s in chroot" % args[0]) - subprocess.call(args, preexec_fn = self.chroot) - - def apply(self): - pass - -class LanguageConfig(KickstartConfig): - """A class to apply a kickstart language configuration to a system.""" - @apply_wrapper - def apply(self, kslang): - self._check_sysconfig() - if kslang.lang: - f = open(self.path("/etc/sysconfig/i18n"), "w+") - f.write("LANG=\"" + kslang.lang + "\"\n") - f.close() - -class KeyboardConfig(KickstartConfig): - """A class to apply a kickstart keyboard configuration to a system.""" - @apply_wrapper - def apply(self, kskeyboard): - # - # FIXME: - # should this impact the X keyboard config too? - # or do we want to make X be able to do this mapping? - # - #k = rhpl.keyboard.Keyboard() - #if kskeyboard.keyboard: - # k.set(kskeyboard.keyboard) - #k.write(self.instroot) - pass - -class TimezoneConfig(KickstartConfig): - """A class to apply a kickstart timezone configuration to a system.""" - @apply_wrapper - def apply(self, kstimezone): - self._check_sysconfig() - tz = kstimezone.timezone or "America/New_York" - utc = str(kstimezone.isUtc) - - f = open(self.path("/etc/sysconfig/clock"), "w+") - f.write("ZONE=\"" + tz + "\"\n") - f.write("UTC=" + utc + "\n") - f.close() - tz_source = "/usr/share/zoneinfo/%s" % (tz) - tz_dest = "/etc/localtime" - try: - cpcmd = fs.find_binary_inchroot('cp', self.instroot) - if cpcmd: - self.call([cpcmd, "-f", tz_source, tz_dest]) - else: - cpcmd = fs.find_binary_path('cp') - subprocess.call([cpcmd, "-f", - self.path(tz_source), - self.path(tz_dest)]) - except (IOError, OSError), (errno, msg): - raise errors.KsError("Timezone setting error: %s" % msg) - -class AuthConfig(KickstartConfig): - """A class to apply a kickstart authconfig configuration to a system.""" - @apply_wrapper - def apply(self, ksauthconfig): - auth = ksauthconfig.authconfig or "--useshadow --enablemd5" - args = ["/usr/share/authconfig/authconfig.py", "--update", "--nostart"] - self.call(args + auth.split()) - -class FirewallConfig(KickstartConfig): - """A class to apply a kickstart firewall configuration to a system.""" - @apply_wrapper - def apply(self, ksfirewall): - # - # FIXME: should handle the rest of the options - # - if not os.path.exists(self.path("/usr/sbin/lokkit")): - return - if ksfirewall.enabled: - status = "--enabled" - else: - status = "--disabled" - - self.call(["/usr/sbin/lokkit", - "-f", "--quiet", "--nostart", status]) - -class RootPasswordConfig(KickstartConfig): - """A class to apply a kickstart root password configuration to a system.""" - def unset(self): - self.call(["/usr/bin/passwd", "-d", "root"]) - - def set_encrypted(self, password): - self.call(["/usr/sbin/usermod", "-p", password, "root"]) - - def set_unencrypted(self, password): - for p in ("/bin/echo", "/usr/sbin/chpasswd"): - if not os.path.exists("%s/%s" %(self.instroot, p)): - raise errors.KsError("Unable to set unencrypted password due " - "to lack of %s" % p) - - p1 = subprocess.Popen(["/bin/echo", "root:%s" %password], - stdout = subprocess.PIPE, - preexec_fn = self.chroot) - p2 = subprocess.Popen(["/usr/sbin/chpasswd", "-m"], - stdin = p1.stdout, - stdout = subprocess.PIPE, - preexec_fn = self.chroot) - p2.communicate() - - @apply_wrapper - def apply(self, ksrootpw): - if ksrootpw.isCrypted: - self.set_encrypted(ksrootpw.password) - elif ksrootpw.password != "": - self.set_unencrypted(ksrootpw.password) - else: - self.unset() - -class UserConfig(KickstartConfig): - def set_empty_passwd(self, user): - self.call(["/usr/bin/passwd", "-d", user]) - - def set_encrypted_passwd(self, user, password): - self.call(["/usr/sbin/usermod", "-p", "%s" % password, user]) - - def set_unencrypted_passwd(self, user, password): - for p in ("/bin/echo", "/usr/sbin/chpasswd"): - if not os.path.exists("%s/%s" %(self.instroot, p)): - raise errors.KsError("Unable to set unencrypted password due " - "to lack of %s" % p) - - p1 = subprocess.Popen(["/bin/echo", "%s:%s" %(user, password)], - stdout = subprocess.PIPE, - preexec_fn = self.chroot) - p2 = subprocess.Popen(["/usr/sbin/chpasswd", "-m"], - stdin = p1.stdout, - stdout = subprocess.PIPE, - preexec_fn = self.chroot) - p2.communicate() - - def addUser(self, userconfig): - args = [ "/usr/sbin/useradd" ] - if userconfig.groups: - args += [ "--groups", string.join(userconfig.groups, ",") ] - if userconfig.name: - args += [ "-m"] - args += [ "-d", "/home/%s" % userconfig.name ] - args.append(userconfig.name) - try: - dev_null = os.open("/dev/null", os.O_WRONLY) - msger.debug('adding user with %s' % args) - subprocess.call(args, - stdout = dev_null, - stderr = dev_null, - preexec_fn = self.chroot) - os.close(dev_null) - except: - msger.warning('Cannot add user using "useradd"') - - if userconfig.password not in (None, ""): - if userconfig.isCrypted: - self.set_encrypted_passwd(userconfig.name, - userconfig.password) - else: - self.set_unencrypted_passwd(userconfig.name, - userconfig.password) - else: - self.set_empty_passwd(userconfig.name) - else: - raise errors.KsError("Invalid kickstart command: %s" \ - % userconfig.__str__()) - - @apply_wrapper - def apply(self, user): - for userconfig in user.userList: - self.addUser(userconfig) - -class ServicesConfig(KickstartConfig): - """A class to apply a kickstart services configuration to a system.""" - @apply_wrapper - def apply(self, ksservices): - if not os.path.exists(self.path("/sbin/chkconfig")): - return - for s in ksservices.enabled: - self.call(["/sbin/chkconfig", s, "on"]) - for s in ksservices.disabled: - self.call(["/sbin/chkconfig", s, "off"]) - -class XConfig(KickstartConfig): - """A class to apply a kickstart X configuration to a system.""" - @apply_wrapper - def apply(self, ksxconfig): - if ksxconfig.startX and os.path.exists(self.path("/etc/inittab")): - f = open(self.path("/etc/inittab"), "rw+") - buf = f.read() - buf = buf.replace("id:3:initdefault", "id:5:initdefault") - f.seek(0) - f.write(buf) - f.close() - if ksxconfig.defaultdesktop: - self._check_sysconfig() - f = open(self.path("/etc/sysconfig/desktop"), "w") - f.write("DESKTOP="+ksxconfig.defaultdesktop+"\n") - f.close() - -class DesktopConfig(KickstartConfig): - """A class to apply a kickstart desktop configuration to a system.""" - @apply_wrapper - def apply(self, ksdesktop): - if ksdesktop.defaultdesktop: - self._check_sysconfig() - f = open(self.path("/etc/sysconfig/desktop"), "w") - f.write("DESKTOP="+ksdesktop.defaultdesktop+"\n") - f.close() - if os.path.exists(self.path("/etc/gdm/custom.conf")): - f = open(self.path("/etc/skel/.dmrc"), "w") - f.write("[Desktop]\n") - f.write("Session="+ksdesktop.defaultdesktop.lower()+"\n") - f.close() - if ksdesktop.session: - if os.path.exists(self.path("/etc/sysconfig/uxlaunch")): - f = open(self.path("/etc/sysconfig/uxlaunch"), "a+") - f.write("session="+ksdesktop.session.lower()+"\n") - f.close() - if ksdesktop.autologinuser: - self._check_sysconfig() - f = open(self.path("/etc/sysconfig/desktop"), "a+") - f.write("AUTOLOGIN_USER=" + ksdesktop.autologinuser + "\n") - f.close() - if os.path.exists(self.path("/etc/gdm/custom.conf")): - f = open(self.path("/etc/gdm/custom.conf"), "w") - f.write("[daemon]\n") - f.write("AutomaticLoginEnable=true\n") - f.write("AutomaticLogin=" + ksdesktop.autologinuser + "\n") - f.close() - -class MoblinRepoConfig(KickstartConfig): - """A class to apply a kickstart desktop configuration to a system.""" - def __create_repo_section(self, repo, type, fd): - baseurl = None - mirrorlist = None - reposuffix = {"base":"", "debuginfo":"-debuginfo", "source":"-source"} - reponame = repo.name + reposuffix[type] - if type == "base": - if repo.baseurl: - baseurl = repo.baseurl - if repo.mirrorlist: - mirrorlist = repo.mirrorlist - - elif type == "debuginfo": - if repo.baseurl: - if repo.baseurl.endswith("/"): - baseurl = os.path.dirname(os.path.dirname(repo.baseurl)) - else: - baseurl = os.path.dirname(repo.baseurl) - baseurl += "/debug" - - if repo.mirrorlist: - variant = repo.mirrorlist[repo.mirrorlist.find("$"):] - mirrorlist = repo.mirrorlist[0:repo.mirrorlist.find("$")] - mirrorlist += "debug" + "-" + variant - - elif type == "source": - if repo.baseurl: - if repo.baseurl.endswith("/"): - baseurl = os.path.dirname( - os.path.dirname( - os.path.dirname(repo.baseurl))) - else: - baseurl = os.path.dirname(os.path.dirname(repo.baseurl)) - baseurl += "/source" - - if repo.mirrorlist: - variant = repo.mirrorlist[repo.mirrorlist.find("$"):] - mirrorlist = repo.mirrorlist[0:repo.mirrorlist.find("$")] - mirrorlist += "source" + "-" + variant - - fd.write("[" + reponame + "]\n") - fd.write("name=" + reponame + "\n") - fd.write("failovermethod=priority\n") - if baseurl: - auth_url = re.compile(AUTH_URL_PTN) - m = auth_url.match(baseurl) - if m: - baseurl = "%s://%s" % (m.group('scheme'), m.group('url')) - fd.write("baseurl=" + baseurl + "\n") - if mirrorlist: - fd.write("mirrorlist=" + mirrorlist + "\n") - """ Skip saving proxy settings """ - #if repo.proxy: - # fd.write("proxy=" + repo.proxy + "\n") - #if repo.proxy_username: - # fd.write("proxy_username=" + repo.proxy_username + "\n") - #if repo.proxy_password: - # fd.write("proxy_password=" + repo.proxy_password + "\n") - if repo.gpgkey: - fd.write("gpgkey=" + repo.gpgkey + "\n") - fd.write("gpgcheck=1\n") - else: - fd.write("gpgcheck=0\n") - if type == "source" or type == "debuginfo" or repo.disable: - fd.write("enabled=0\n") - else: - fd.write("enabled=1\n") - fd.write("\n") - - def __create_repo_file(self, repo, repodir): - fs.makedirs(self.path(repodir)) - f = open(self.path(repodir + "/" + repo.name + ".repo"), "w") - self.__create_repo_section(repo, "base", f) - if repo.debuginfo: - self.__create_repo_section(repo, "debuginfo", f) - if repo.source: - self.__create_repo_section(repo, "source", f) - f.close() - - @apply_wrapper - def apply(self, ksrepo, repodata, repourl): - for repo in ksrepo.repoList: - if repo.name in repourl: - repo.baseurl = repourl[repo.name] - if repo.save: - #self.__create_repo_file(repo, "/etc/yum.repos.d") - self.__create_repo_file(repo, "/etc/zypp/repos.d") - """ Import repo gpg keys """ - if repodata: - for repo in repodata: - if repo['repokey']: - runner.quiet(['rpm', - "--root=%s" % self.instroot, - "--import", - repo['repokey']]) - -class RPMMacroConfig(KickstartConfig): - """A class to apply the specified rpm macros to the filesystem""" - @apply_wrapper - def apply(self, ks): - if not ks: - return - if not os.path.exists(self.path("/etc/rpm")): - os.mkdir(self.path("/etc/rpm")) - f = open(self.path("/etc/rpm/macros.imgcreate"), "w+") - if exclude_docs(ks): - f.write("%_excludedocs 1\n") - f.write("%__file_context_path %{nil}\n") - if inst_langs(ks) != None: - f.write("%_install_langs ") - f.write(inst_langs(ks)) - f.write("\n") - f.close() - -class NetworkConfig(KickstartConfig): - """A class to apply a kickstart network configuration to a system.""" - def write_ifcfg(self, network): - p = self.path("/etc/sysconfig/network-scripts/ifcfg-" + network.device) - - f = file(p, "w+") - os.chmod(p, 0644) - - f.write("DEVICE=%s\n" % network.device) - f.write("BOOTPROTO=%s\n" % network.bootProto) - - if network.bootProto.lower() == "static": - if network.ip: - f.write("IPADDR=%s\n" % network.ip) - if network.netmask: - f.write("NETMASK=%s\n" % network.netmask) - - if network.onboot: - f.write("ONBOOT=on\n") - else: - f.write("ONBOOT=off\n") - - if network.essid: - f.write("ESSID=%s\n" % network.essid) - - if network.ethtool: - if network.ethtool.find("autoneg") == -1: - network.ethtool = "autoneg off " + network.ethtool - f.write("ETHTOOL_OPTS=%s\n" % network.ethtool) - - if network.bootProto.lower() == "dhcp": - if network.hostname: - f.write("DHCP_HOSTNAME=%s\n" % network.hostname) - if network.dhcpclass: - f.write("DHCP_CLASSID=%s\n" % network.dhcpclass) - - if network.mtu: - f.write("MTU=%s\n" % network.mtu) - - f.close() - - def write_wepkey(self, network): - if not network.wepkey: - return - - p = self.path("/etc/sysconfig/network-scripts/keys-" + network.device) - f = file(p, "w+") - os.chmod(p, 0600) - f.write("KEY=%s\n" % network.wepkey) - f.close() - - def write_sysconfig(self, useipv6, hostname, gateway): - path = self.path("/etc/sysconfig/network") - f = file(path, "w+") - os.chmod(path, 0644) - - f.write("NETWORKING=yes\n") - - if useipv6: - f.write("NETWORKING_IPV6=yes\n") - else: - f.write("NETWORKING_IPV6=no\n") - - if hostname: - f.write("HOSTNAME=%s\n" % hostname) - else: - f.write("HOSTNAME=localhost.localdomain\n") - - if gateway: - f.write("GATEWAY=%s\n" % gateway) - - f.close() - - def write_hosts(self, hostname): - localline = "" - if hostname and hostname != "localhost.localdomain": - localline += hostname + " " - l = hostname.split(".") - if len(l) > 1: - localline += l[0] + " " - localline += "localhost.localdomain localhost" - - path = self.path("/etc/hosts") - f = file(path, "w+") - os.chmod(path, 0644) - f.write("127.0.0.1\t\t%s\n" % localline) - f.write("::1\t\tlocalhost6.localdomain6 localhost6\n") - f.close() - - def write_resolv(self, nodns, nameservers): - if nodns or not nameservers: - return - - path = self.path("/etc/resolv.conf") - f = file(path, "w+") - os.chmod(path, 0644) - - for ns in (nameservers): - if ns: - f.write("nameserver %s\n" % ns) - - f.close() - - @apply_wrapper - def apply(self, ksnet): - fs.makedirs(self.path("/etc/sysconfig/network-scripts")) - - useipv6 = False - nodns = False - hostname = None - gateway = None - nameservers = None - - for network in ksnet.network: - if not network.device: - raise errors.KsError("No --device specified with " - "network kickstart command") - - if (network.onboot and network.bootProto.lower() != "dhcp" and - not (network.ip and network.netmask)): - raise errors.KsError("No IP address and/or netmask " - "specified with static " - "configuration for '%s'" % - network.device) - - self.write_ifcfg(network) - self.write_wepkey(network) - - if network.ipv6: - useipv6 = True - if network.nodns: - nodns = True - - if network.hostname: - hostname = network.hostname - if network.gateway: - gateway = network.gateway - - if network.nameserver: - nameservers = network.nameserver.split(",") - - self.write_sysconfig(useipv6, hostname, gateway) - self.write_hosts(hostname) - self.write_resolv(nodns, nameservers) - -def use_installerfw(ks, feature): - """ Check if the installer framework has to be used for a feature - "feature". """ - - features = ks.handler.installerfw.features - if features: - if feature in features or "all" in features: - return True - return False - -def get_image_size(ks, default = None): - __size = 0 - for p in ks.handler.partition.partitions: - if p.mountpoint == "/" and p.size: - __size = p.size - if __size > 0: - return int(__size) * 1024L * 1024L - else: - return default - -def get_image_fstype(ks, default = None): - for p in ks.handler.partition.partitions: - if p.mountpoint == "/" and p.fstype: - return p.fstype - return default - -def get_image_fsopts(ks, default = None): - for p in ks.handler.partition.partitions: - if p.mountpoint == "/" and p.fsopts: - return p.fsopts - return default - -def get_modules(ks): - devices = [] - if isinstance(ks.handler.device, kscommands.device.FC3_Device): - devices.append(ks.handler.device) - else: - devices.extend(ks.handler.device.deviceList) - - modules = [] - for device in devices: - if not device.moduleName: - continue - modules.extend(device.moduleName.split(":")) - - return modules - -def get_timeout(ks, default = None): - if not hasattr(ks.handler.bootloader, "timeout"): - return default - if ks.handler.bootloader.timeout is None: - return default - return int(ks.handler.bootloader.timeout) - -def get_kernel_args(ks, default = "ro rd.live.image"): - if not hasattr(ks.handler.bootloader, "appendLine"): - return default - if ks.handler.bootloader.appendLine is None: - return default - return "%s %s" %(default, ks.handler.bootloader.appendLine) - -def get_menu_args(ks, default = ""): - if not hasattr(ks.handler.bootloader, "menus"): - return default - if ks.handler.bootloader.menus in (None, ""): - return default - return "%s" % ks.handler.bootloader.menus - -def get_default_kernel(ks, default = None): - if not hasattr(ks.handler.bootloader, "default"): - return default - if not ks.handler.bootloader.default: - return default - return ks.handler.bootloader.default - -def get_repos(ks, repo_urls=None): - repos = {} - for repo in ks.handler.repo.repoList: - inc = [] - if hasattr(repo, "includepkgs"): - inc.extend(repo.includepkgs) - - exc = [] - if hasattr(repo, "excludepkgs"): - exc.extend(repo.excludepkgs) - - baseurl = repo.baseurl - mirrorlist = repo.mirrorlist - - if repo_urls and repo.name in repo_urls: - baseurl = repo_urls[repo.name] - mirrorlist = None - - if repos.has_key(repo.name): - msger.warning("Overriding already specified repo %s" %(repo.name,)) - - proxy = None - if hasattr(repo, "proxy"): - proxy = repo.proxy - proxy_username = None - if hasattr(repo, "proxy_username"): - proxy_username = repo.proxy_username - proxy_password = None - if hasattr(repo, "proxy_password"): - proxy_password = repo.proxy_password - if hasattr(repo, "debuginfo"): - debuginfo = repo.debuginfo - if hasattr(repo, "source"): - source = repo.source - if hasattr(repo, "gpgkey"): - gpgkey = repo.gpgkey - if hasattr(repo, "disable"): - disable = repo.disable - ssl_verify = True - if hasattr(repo, "ssl_verify"): - ssl_verify = repo.ssl_verify == "yes" - nocache = False - if hasattr(repo, "nocache"): - nocache = repo.nocache - cost = None - if hasattr(repo, "cost"): - cost = repo.cost - priority = None - if hasattr(repo, "priority"): - priority = repo.priority - - repos[repo.name] = (repo.name, baseurl, mirrorlist, inc, exc, - proxy, proxy_username, proxy_password, debuginfo, - source, gpgkey, disable, ssl_verify, nocache, - cost, priority) - - return repos.values() - -def convert_method_to_repo(ks): - try: - ks.handler.repo.methodToRepo() - except (AttributeError, kserrors.KickstartError): - pass - -def get_attachment(ks, required=()): - return ks.handler.attachment.packageList + list(required) - -def get_pre_packages(ks, required=()): - return ks.handler.prepackages.packageList + list(required) - -def get_packages(ks, required=()): - return ks.handler.packages.packageList + list(required) - -def get_groups(ks, required=()): - return ks.handler.packages.groupList + list(required) - -def get_excluded(ks, required=()): - return ks.handler.packages.excludedList + list(required) - -def get_partitions(ks): - return ks.handler.partition.partitions - -def ignore_missing(ks): - return ks.handler.packages.handleMissing == ksconstants.KS_MISSING_IGNORE - -def exclude_docs(ks): - return ks.handler.packages.excludeDocs - -def inst_langs(ks): - if hasattr(ks.handler.packages, "instLange"): - return ks.handler.packages.instLange - elif hasattr(ks.handler.packages, "instLangs"): - return ks.handler.packages.instLangs - return "" - -def get_post_scripts(ks): - scripts = [] - for s in ks.handler.scripts: - if s.type != ksparser.KS_SCRIPT_POST: - continue - scripts.append(s) - return scripts - -def add_repo(ks, repostr): - args = repostr.split() - repoobj = ks.handler.repo.parse(args[1:]) - if repoobj and repoobj not in ks.handler.repo.repoList: - ks.handler.repo.repoList.append(repoobj) - -def remove_all_repos(ks): - while len(ks.handler.repo.repoList) != 0: - del ks.handler.repo.repoList[0] - -def remove_duplicate_repos(ks): - i = 0 - j = i + 1 - while True: - if len(ks.handler.repo.repoList) < 2: - break - if i >= len(ks.handler.repo.repoList) - 1: - break - name = ks.handler.repo.repoList[i].name - baseurl = ks.handler.repo.repoList[i].baseurl - if j < len(ks.handler.repo.repoList): - if (ks.handler.repo.repoList[j].name == name or \ - ks.handler.repo.repoList[j].baseurl == baseurl): - del ks.handler.repo.repoList[j] - else: - j += 1 - if j >= len(ks.handler.repo.repoList): - i += 1 - j = i + 1 - else: - i += 1 - j = i + 1 - -def resolve_groups(creatoropts, repometadata): - iszypp = False - if 'zypp' == creatoropts['pkgmgr']: - iszypp = True - ks = creatoropts['ks'] - - for repo in repometadata: - """ Mustn't replace group with package list if repo is ready for the - corresponding package manager. - """ - - if iszypp and repo["patterns"]: - continue - if not iszypp and repo["comps"]: - continue - - # But we also must handle such cases, use zypp but repo only has comps, - # use yum but repo only has patterns, use zypp but use_comps is true, - # use yum but use_comps is false. - groupfile = None - if iszypp and repo["comps"]: - groupfile = repo["comps"] - get_pkglist_handler = misc.get_pkglist_in_comps - if not iszypp and repo["patterns"]: - groupfile = repo["patterns"] - get_pkglist_handler = misc.get_pkglist_in_patterns - - if groupfile: - i = 0 - while True: - if i >= len(ks.handler.packages.groupList): - break - pkglist = get_pkglist_handler( - ks.handler.packages.groupList[i].name, - groupfile) - if pkglist: - del ks.handler.packages.groupList[i] - for pkg in pkglist: - if pkg not in ks.handler.packages.packageList: - ks.handler.packages.packageList.append(pkg) - else: - i = i + 1 diff --git a/scripts/lib/mic/kickstart/custom_commands/__init__.py b/scripts/lib/mic/kickstart/custom_commands/__init__.py deleted file mode 100644 index 6aed0ff6fa..0000000000 --- a/scripts/lib/mic/kickstart/custom_commands/__init__.py +++ /dev/null @@ -1,17 +0,0 @@ -from desktop import Mic_Desktop -from micrepo import Mic_Repo, Mic_RepoData -from micpartition import Mic_Partition -from micpartition import Mic_PartData -from installerfw import Mic_installerfw -from partition import Wic_Partition - -__all__ = ( - "Mic_Desktop", - "Mic_Repo", - "Mic_RepoData", - "Mic_Partition", - "Mic_PartData", - "Mic_installerfw", - "Wic_Partition", - "Wic_PartData", -) diff --git a/scripts/lib/mic/kickstart/custom_commands/desktop.py b/scripts/lib/mic/kickstart/custom_commands/desktop.py deleted file mode 100644 index c8bd647ae3..0000000000 --- a/scripts/lib/mic/kickstart/custom_commands/desktop.py +++ /dev/null @@ -1,95 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2008, 2009, 2010 Intel, Inc. -# -# Yi Yang <yi.y.yang@intel.com> -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * - -class Mic_Desktop(KickstartCommand): - def __init__(self, writePriority=0, - defaultdesktop=None, - defaultdm=None, - autologinuser=None, - session=None): - - KickstartCommand.__init__(self, writePriority) - - self.__new_version = False - self.op = self._getParser() - - self.defaultdesktop = defaultdesktop - self.autologinuser = autologinuser - self.defaultdm = defaultdm - self.session = session - - def __str__(self): - retval = "" - - if self.defaultdesktop != None: - retval += " --defaultdesktop=%s" % self.defaultdesktop - if self.session != None: - retval += " --session=\"%s\"" % self.session - if self.autologinuser != None: - retval += " --autologinuser=%s" % self.autologinuser - if self.defaultdm != None: - retval += " --defaultdm=%s" % self.defaultdm - - if retval != "": - retval = "# Default Desktop Settings\ndesktop %s\n" % retval - - return retval - - def _getParser(self): - try: - op = KSOptionParser(lineno=self.lineno) - except TypeError: - # the latest version has not lineno argument - op = KSOptionParser() - self.__new_version = True - - op.add_option("--defaultdesktop", dest="defaultdesktop", - action="store", - type="string", - nargs=1) - op.add_option("--autologinuser", dest="autologinuser", - action="store", - type="string", - nargs=1) - op.add_option("--defaultdm", dest="defaultdm", - action="store", - type="string", - nargs=1) - op.add_option("--session", dest="session", - action="store", - type="string", - nargs=1) - return op - - def parse(self, args): - if self.__new_version: - (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) - else: - (opts, extra) = self.op.parse_args(args=args) - - if extra: - m = _("Unexpected arguments to %(command)s command: %(options)s") \ - % {"command": "desktop", "options": extra} - raise KickstartValueError, formatErrorMsg(self.lineno, msg=m) - - self._setToSelf(self.op, opts) diff --git a/scripts/lib/mic/kickstart/custom_commands/installerfw.py b/scripts/lib/mic/kickstart/custom_commands/installerfw.py deleted file mode 100644 index 2466f1dc07..0000000000 --- a/scripts/lib/mic/kickstart/custom_commands/installerfw.py +++ /dev/null @@ -1,63 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2013 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -from pykickstart.base import * -from pykickstart.options import * - -class Mic_installerfw(KickstartCommand): - """ This class implements the "installerfw" KS option. The argument - of the option is a comman-separated list of MIC features which have to be - disabled and instead, will be done in the installer. For example, - "installerfw=extlinux" disables all the MIC code which installs extlinux to - the target images, and instead, the extlinux or whatever boot-loader will - be installed by the installer instead. - - The installer is a tool which is external to MIC, it comes from the - installation repositories and can be executed by MIC in order to perform - various configuration actions. The main point here is to make sure MIC has - no hard-wired knoledge about the target OS configuration. """ - - removedKeywords = KickstartCommand.removedKeywords - removedAttrs = KickstartCommand.removedAttrs - - def __init__(self, *args, **kwargs): - KickstartCommand.__init__(self, *args, **kwargs) - self.op = self._getParser() - self.features = kwargs.get("installerfw", None) - - def __str__(self): - retval = KickstartCommand.__str__(self) - - if self.features: - retval += "# Enable installer framework features\ninstallerfw\n" - - return retval - - def _getParser(self): - op = KSOptionParser() - return op - - def parse(self, args): - (_, extra) = self.op.parse_args(args=args, lineno=self.lineno) - - if len(extra) != 1: - msg = "Kickstart command \"installerfw\" requires one " \ - "argumet - a list of legacy features to disable" - raise KickstartValueError, formatErrorMsg(self.lineno, msg = msg) - - self.features = extra[0].split(",") - return self diff --git a/scripts/lib/mic/kickstart/custom_commands/micboot.py b/scripts/lib/mic/kickstart/custom_commands/micboot.py deleted file mode 100644 index 66d1678aa7..0000000000 --- a/scripts/lib/mic/kickstart/custom_commands/micboot.py +++ /dev/null @@ -1,49 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2008, 2009, 2010 Intel, Inc. -# -# Anas Nashif -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * -from pykickstart.commands.bootloader import * - -class Mic_Bootloader(F8_Bootloader): - def __init__(self, writePriority=10, appendLine="", driveorder=None, - forceLBA=False, location="", md5pass="", password="", - upgrade=False, menus=""): - F8_Bootloader.__init__(self, writePriority, appendLine, driveorder, - forceLBA, location, md5pass, password, upgrade) - - self.menus = "" - self.ptable = "msdos" - - def _getArgsAsStr(self): - ret = F8_Bootloader._getArgsAsStr(self) - - if self.menus == "": - ret += " --menus=%s" %(self.menus,) - if self.ptable: - ret += " --ptable=\"%s\"" %(self.ptable,) - return ret - - def _getParser(self): - op = F8_Bootloader._getParser(self) - op.add_option("--menus", dest="menus") - op.add_option("--ptable", dest="ptable", type="string") - return op - diff --git a/scripts/lib/mic/kickstart/custom_commands/micpartition.py b/scripts/lib/mic/kickstart/custom_commands/micpartition.py deleted file mode 100644 index 59a87fb486..0000000000 --- a/scripts/lib/mic/kickstart/custom_commands/micpartition.py +++ /dev/null @@ -1,57 +0,0 @@ -#!/usr/bin/python -tt -# -# Marko Saukko <marko.saukko@cybercom.com> -# -# Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). -# -# This copyrighted material is made available to anyone wishing to use, modify, -# copy, or redistribute it subject to the terms and conditions of the GNU -# General Public License v.2. This program is distributed in the hope that it -# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the -# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along with -# this program; if not, write to the Free Software Foundation, Inc., 51 -# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - -from pykickstart.commands.partition import * - -class Mic_PartData(FC4_PartData): - removedKeywords = FC4_PartData.removedKeywords - removedAttrs = FC4_PartData.removedAttrs - - def __init__(self, *args, **kwargs): - FC4_PartData.__init__(self, *args, **kwargs) - self.deleteRemovedAttrs() - self.align = kwargs.get("align", None) - self.extopts = kwargs.get("extopts", None) - self.part_type = kwargs.get("part_type", None) - - def _getArgsAsStr(self): - retval = FC4_PartData._getArgsAsStr(self) - - if self.align: - retval += " --align" - if self.extopts: - retval += " --extoptions=%s" % self.extopts - if self.part_type: - retval += " --part-type=%s" % self.part_type - - return retval - -class Mic_Partition(FC4_Partition): - removedKeywords = FC4_Partition.removedKeywords - removedAttrs = FC4_Partition.removedAttrs - - def _getParser(self): - op = FC4_Partition._getParser(self) - # The alignment value is given in kBytes. e.g., value 8 means that - # the partition is aligned to start from 8096 byte boundary. - op.add_option("--align", type="int", action="store", dest="align", - default=None) - op.add_option("--extoptions", type="string", action="store", dest="extopts", - default=None) - op.add_option("--part-type", type="string", action="store", dest="part_type", - default=None) - return op diff --git a/scripts/lib/mic/kickstart/custom_commands/micrepo.py b/scripts/lib/mic/kickstart/custom_commands/micrepo.py deleted file mode 100644 index b31576e400..0000000000 --- a/scripts/lib/mic/kickstart/custom_commands/micrepo.py +++ /dev/null @@ -1,127 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2008, 2009, 2010 Intel, Inc. -# -# Yi Yang <yi.y.yang@intel.com> -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * -from pykickstart.commands.repo import * - -class Mic_RepoData(F8_RepoData): - - def __init__(self, baseurl="", mirrorlist=None, name="", priority=None, - includepkgs=(), excludepkgs=(), save=False, proxy=None, - proxy_username=None, proxy_password=None, debuginfo=False, - source=False, gpgkey=None, disable=False, ssl_verify="yes", - nocache=False): - kw = {} - # F8_RepoData keywords - if includepkgs: - kw['includepkgs'] = includepkgs - if excludepkgs: - kw['excludepkgs'] = excludepkgs - - #FC6_RepoData keywords - if baseurl: - kw['baseurl'] = baseurl - if mirrorlist: - kw['mirrorlist'] = mirrorlist - if name: - kw['name'] = name - - F8_RepoData.__init__(self, **kw) - self.save = save - self.proxy = proxy - self.proxy_username = proxy_username - self.proxy_password = proxy_password - self.debuginfo = debuginfo - self.disable = disable - self.source = source - self.gpgkey = gpgkey - self.ssl_verify = ssl_verify.lower() - self.priority = priority - self.nocache = nocache - - def _getArgsAsStr(self): - retval = F8_RepoData._getArgsAsStr(self) - - if self.save: - retval += " --save" - if self.proxy: - retval += " --proxy=%s" % self.proxy - if self.proxy_username: - retval += " --proxyuser=%s" % self.proxy_username - if self.proxy_password: - retval += " --proxypasswd=%s" % self.proxy_password - if self.debuginfo: - retval += " --debuginfo" - if self.source: - retval += " --source" - if self.gpgkey: - retval += " --gpgkey=%s" % self.gpgkey - if self.disable: - retval += " --disable" - if self.ssl_verify: - retval += " --ssl_verify=%s" % self.ssl_verify - if self.priority: - retval += " --priority=%s" % self.priority - if self.nocache: - retval += " --nocache" - - return retval - -class Mic_Repo(F8_Repo): - def __init__(self, writePriority=0, repoList=None): - F8_Repo.__init__(self, writePriority, repoList) - - def __str__(self): - retval = "" - for repo in self.repoList: - retval += repo.__str__() - - return retval - - def _getParser(self): - def list_cb (option, opt_str, value, parser): - for d in value.split(','): - parser.values.ensure_value(option.dest, []).append(d) - - op = F8_Repo._getParser(self) - op.add_option("--save", action="store_true", dest="save", - default=False) - op.add_option("--proxy", type="string", action="store", dest="proxy", - default=None, nargs=1) - op.add_option("--proxyuser", type="string", action="store", - dest="proxy_username", default=None, nargs=1) - op.add_option("--proxypasswd", type="string", action="store", - dest="proxy_password", default=None, nargs=1) - op.add_option("--debuginfo", action="store_true", dest="debuginfo", - default=False) - op.add_option("--source", action="store_true", dest="source", - default=False) - op.add_option("--disable", action="store_true", dest="disable", - default=False) - op.add_option("--gpgkey", type="string", action="store", dest="gpgkey", - default=None, nargs=1) - op.add_option("--ssl_verify", type="string", action="store", - dest="ssl_verify", default="yes") - op.add_option("--priority", type="int", action="store", dest="priority", - default=None) - op.add_option("--nocache", action="store_true", dest="nocache", - default=False) - return op diff --git a/scripts/lib/mic/kickstart/custom_commands/partition.py b/scripts/lib/mic/kickstart/custom_commands/partition.py deleted file mode 100644 index 3b652b399c..0000000000 --- a/scripts/lib/mic/kickstart/custom_commands/partition.py +++ /dev/null @@ -1,496 +0,0 @@ -# ex:ts=4:sw=4:sts=4:et -# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- -# -# Copyright (c) 2013, Intel Corporation. -# All rights reserved. -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License version 2 as -# published by the Free Software Foundation. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., -# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. -# -# DESCRIPTION -# This module provides the OpenEmbedded partition object definitions. -# -# AUTHORS -# Tom Zanussi <tom.zanussi (at] linux.intel.com> -# - -import shutil -import os -import tempfile - -from pykickstart.commands.partition import * -from mic.utils.oe.misc import * -from mic.kickstart.custom_commands import * -from mic.plugin import pluginmgr - -partition_methods = { - "do_stage_partition":None, - "do_prepare_partition":None, - "do_configure_partition":None, -} - -class Wic_PartData(Mic_PartData): - removedKeywords = Mic_PartData.removedKeywords - removedAttrs = Mic_PartData.removedAttrs - - def __init__(self, *args, **kwargs): - Mic_PartData.__init__(self, *args, **kwargs) - self.deleteRemovedAttrs() - self.source = kwargs.get("source", None) - self.rootfs = kwargs.get("rootfs-dir", None) - self.source_file = "" - self.size = 0 - - def _getArgsAsStr(self): - retval = Mic_PartData._getArgsAsStr(self) - - if self.source: - retval += " --source=%s" % self.source - if self.rootfs: - retval += " --rootfs-dir=%s" % self.rootfs - - return retval - - def get_rootfs(self): - """ - Acessor for rootfs dir - """ - return self.rootfs - - def set_rootfs(self, rootfs): - """ - Acessor for actual rootfs dir, which must be set by source - plugins. - """ - self.rootfs = rootfs - - def get_size(self): - """ - Accessor for partition size, 0 or --size before set_size(). - """ - return self.size - - def set_size(self, size): - """ - Accessor for actual partition size, which must be set by source - plugins. - """ - self.size = size - - def set_source_file(self, source_file): - """ - Accessor for source_file, the location of the generated partition - image, which must be set by source plugins. - """ - self.source_file = source_file - - def get_extra_block_count(self, current_blocks): - """ - The --size param is reflected in self.size (in MB), and we already - have current_blocks (1k) blocks, calculate and return the - number of (1k) blocks we need to add to get to --size, 0 if - we're already there or beyond. - """ - msger.debug("Requested partition size for %s: %d" % \ - (self.mountpoint, self.size)) - - if not self.size: - return 0 - - requested_blocks = self.size * 1024 - - msger.debug("Requested blocks %d, current_blocks %d" % \ - (requested_blocks, current_blocks)) - - if requested_blocks > current_blocks: - return requested_blocks - current_blocks - else: - return 0 - - def prepare(self, cr, cr_workdir, oe_builddir, rootfs_dir, bootimg_dir, - kernel_dir, native_sysroot): - """ - Prepare content for individual partitions, depending on - partition command parameters. - """ - if not self.source: - if not self.size: - msger.error("The %s partition has a size of zero. Please specify a non-zero --size for that partition." % self.mountpoint) - if self.fstype and self.fstype == "swap": - self.prepare_swap_partition(cr_workdir, oe_builddir, - native_sysroot) - elif self.fstype: - self.prepare_empty_partition(cr_workdir, oe_builddir, - native_sysroot) - return - - plugins = pluginmgr.get_source_plugins() - - if self.source not in plugins: - msger.error("The '%s' --source specified for %s doesn't exist.\n\tSee 'wic list source-plugins' for a list of available --sources.\n\tSee 'wic help source-plugins' for details on adding a new source plugin." % (self.source, self.mountpoint)) - - self._source_methods = pluginmgr.get_source_plugin_methods(self.source, partition_methods) - self._source_methods["do_configure_partition"](self, cr, cr_workdir, - oe_builddir, - bootimg_dir, - kernel_dir, - native_sysroot) - self._source_methods["do_stage_partition"](self, cr, cr_workdir, - oe_builddir, - bootimg_dir, kernel_dir, - native_sysroot) - self._source_methods["do_prepare_partition"](self, cr, cr_workdir, - oe_builddir, - bootimg_dir, kernel_dir, rootfs_dir, - native_sysroot) - - def prepare_rootfs_from_fs_image(self, cr_workdir, oe_builddir, - rootfs_dir): - """ - Handle an already-created partition e.g. xxx.ext3 - """ - rootfs = oe_builddir - du_cmd = "du -Lbms %s" % rootfs - rc, out = exec_cmd(du_cmd) - rootfs_size = out.split()[0] - - self.size = rootfs_size - self.source_file = rootfs - - def prepare_rootfs(self, cr_workdir, oe_builddir, rootfs_dir, - native_sysroot): - """ - Prepare content for a rootfs partition i.e. create a partition - and fill it from a /rootfs dir. - - Currently handles ext2/3/4 and btrfs. - """ - pseudo = "export PSEUDO_PREFIX=%s/usr;" % native_sysroot - pseudo += "export PSEUDO_LOCALSTATEDIR=%s/../pseudo;" % rootfs_dir - pseudo += "export PSEUDO_PASSWD=%s;" % rootfs_dir - pseudo += "export PSEUDO_NOSYMLINKEXP=1;" - pseudo += "%s/usr/bin/pseudo " % native_sysroot - - if self.fstype.startswith("ext"): - return self.prepare_rootfs_ext(cr_workdir, oe_builddir, - rootfs_dir, native_sysroot, - pseudo) - elif self.fstype.startswith("btrfs"): - return self.prepare_rootfs_btrfs(cr_workdir, oe_builddir, - rootfs_dir, native_sysroot, - pseudo) - - elif self.fstype.startswith("vfat"): - return self.prepare_rootfs_vfat(cr_workdir, oe_builddir, - rootfs_dir, native_sysroot, - pseudo) - elif self.fstype.startswith("squashfs"): - return self.prepare_rootfs_squashfs(cr_workdir, oe_builddir, - rootfs_dir, native_sysroot, - pseudo) - - def prepare_rootfs_ext(self, cr_workdir, oe_builddir, rootfs_dir, - native_sysroot, pseudo): - """ - Prepare content for an ext2/3/4 rootfs partition. - """ - - image_rootfs = rootfs_dir - rootfs = "%s/rootfs_%s.%s" % (cr_workdir, self.label ,self.fstype) - - du_cmd = "du -ks %s" % image_rootfs - rc, out = exec_cmd(du_cmd) - actual_rootfs_size = int(out.split()[0]) - - extra_blocks = self.get_extra_block_count(actual_rootfs_size) - - if extra_blocks < IMAGE_EXTRA_SPACE: - extra_blocks = IMAGE_EXTRA_SPACE - - rootfs_size = actual_rootfs_size + extra_blocks - - msger.debug("Added %d extra blocks to %s to get to %d total blocks" % \ - (extra_blocks, self.mountpoint, rootfs_size)) - - dd_cmd = "dd if=/dev/zero of=%s bs=1024 seek=%d count=0 bs=1k" % \ - (rootfs, rootfs_size) - rc, out = exec_cmd(dd_cmd) - - extra_imagecmd = "-i 8192" - - mkfs_cmd = "mkfs.%s -F %s %s -d %s" % \ - (self.fstype, extra_imagecmd, rootfs, image_rootfs) - rc, out = exec_native_cmd(pseudo + mkfs_cmd, native_sysroot) - - - # get the rootfs size in the right units for kickstart (Mb) - du_cmd = "du -Lbms %s" % rootfs - rc, out = exec_cmd(du_cmd) - rootfs_size = out.split()[0] - - self.size = rootfs_size - self.source_file = rootfs - - return 0 - - def prepare_rootfs_btrfs(self, cr_workdir, oe_builddir, rootfs_dir, - native_sysroot, pseudo): - """ - Prepare content for a btrfs rootfs partition. - - Currently handles ext2/3/4 and btrfs. - """ - image_rootfs = rootfs_dir - rootfs = "%s/rootfs_%s.%s" % (cr_workdir, self.label, self.fstype) - - du_cmd = "du -ks %s" % image_rootfs - rc, out = exec_cmd(du_cmd) - actual_rootfs_size = int(out.split()[0]) - - extra_blocks = self.get_extra_block_count(actual_rootfs_size) - - if extra_blocks < IMAGE_EXTRA_SPACE: - extra_blocks = IMAGE_EXTRA_SPACE - - rootfs_size = actual_rootfs_size + extra_blocks - - msger.debug("Added %d extra blocks to %s to get to %d total blocks" % \ - (extra_blocks, self.mountpoint, rootfs_size)) - - dd_cmd = "dd if=/dev/zero of=%s bs=1024 seek=%d count=0 bs=1k" % \ - (rootfs, rootfs_size) - rc, out = exec_cmd(dd_cmd) - - mkfs_cmd = "mkfs.%s -b %d -r %s %s" % \ - (self.fstype, rootfs_size * 1024, image_rootfs, rootfs) - rc, out = exec_native_cmd(pseudo + mkfs_cmd, native_sysroot) - - # get the rootfs size in the right units for kickstart (Mb) - du_cmd = "du -Lbms %s" % rootfs - rc, out = exec_cmd(du_cmd) - rootfs_size = out.split()[0] - - self.size = rootfs_size - self.source_file = rootfs - - def prepare_rootfs_vfat(self, cr_workdir, oe_builddir, rootfs_dir, - native_sysroot, pseudo): - """ - Prepare content for a vfat rootfs partition. - """ - image_rootfs = rootfs_dir - rootfs = "%s/rootfs_%s.%s" % (cr_workdir, self.label, self.fstype) - - du_cmd = "du -bks %s" % image_rootfs - rc, out = exec_cmd(du_cmd) - blocks = int(out.split()[0]) - - extra_blocks = self.get_extra_block_count(blocks) - - if extra_blocks < BOOTDD_EXTRA_SPACE: - extra_blocks = BOOTDD_EXTRA_SPACE - - blocks += extra_blocks - - msger.debug("Added %d extra blocks to %s to get to %d total blocks" % \ - (extra_blocks, self.mountpoint, blocks)) - - # Ensure total sectors is an integral number of sectors per - # track or mcopy will complain. Sectors are 512 bytes, and we - # generate images with 32 sectors per track. This calculation is - # done in blocks, thus the mod by 16 instead of 32. - blocks += (16 - (blocks % 16)) - - dosfs_cmd = "mkdosfs -n boot -S 512 -C %s %d" % (rootfs, blocks) - exec_native_cmd(dosfs_cmd, native_sysroot) - - mcopy_cmd = "mcopy -i %s -s %s/* ::/" % (rootfs, image_rootfs) - rc, out = exec_native_cmd(mcopy_cmd, native_sysroot) - if rc: - msger.error("ERROR: mcopy returned '%s' instead of 0 (which you probably don't want to ignore, use --debug for details)" % rc) - - chmod_cmd = "chmod 644 %s" % rootfs - exec_cmd(chmod_cmd) - - # get the rootfs size in the right units for kickstart (Mb) - du_cmd = "du -Lbms %s" % rootfs - rc, out = exec_cmd(du_cmd) - rootfs_size = out.split()[0] - - self.set_size(rootfs_size) - self.set_source_file(rootfs) - - def prepare_rootfs_squashfs(self, cr_workdir, oe_builddir, rootfs_dir, - native_sysroot, pseudo): - """ - Prepare content for a squashfs rootfs partition. - """ - image_rootfs = rootfs_dir - rootfs = "%s/rootfs_%s.%s" % (cr_workdir, self.label ,self.fstype) - - squashfs_cmd = "mksquashfs %s %s -noappend" % \ - (image_rootfs, rootfs) - rc, out = exec_native_cmd(pseudo + squashfs_cmd, native_sysroot) - - # get the rootfs size in the right units for kickstart (Mb) - du_cmd = "du -Lbms %s" % rootfs - rc, out = exec_cmd(du_cmd) - rootfs_size = out.split()[0] - - self.size = rootfs_size - self.source_file = rootfs - - return 0 - - def prepare_empty_partition(self, cr_workdir, oe_builddir, native_sysroot): - """ - Prepare an empty partition. - """ - if self.fstype.startswith("ext"): - return self.prepare_empty_partition_ext(cr_workdir, oe_builddir, - native_sysroot) - elif self.fstype.startswith("btrfs"): - return self.prepare_empty_partition_btrfs(cr_workdir, oe_builddir, - native_sysroot) - elif self.fstype.startswith("vfat"): - return self.prepare_empty_partition_vfat(cr_workdir, oe_builddir, - native_sysroot) - elif self.fstype.startswith("squashfs"): - return self.prepare_empty_partition_squashfs(cr_workdir, oe_builddir, - native_sysroot) - - def prepare_empty_partition_ext(self, cr_workdir, oe_builddir, - native_sysroot): - """ - Prepare an empty ext2/3/4 partition. - """ - fs = "%s/fs.%s" % (cr_workdir, self.fstype) - - dd_cmd = "dd if=/dev/zero of=%s bs=1M seek=%d count=0" % \ - (fs, self.size) - rc, out = exec_cmd(dd_cmd) - - extra_imagecmd = "-i 8192" - - mkfs_cmd = "mkfs.%s -F %s %s" % (self.fstype, extra_imagecmd, fs) - rc, out = exec_native_cmd(mkfs_cmd, native_sysroot) - - self.source_file = fs - - return 0 - - def prepare_empty_partition_btrfs(self, cr_workdir, oe_builddir, - native_sysroot): - """ - Prepare an empty btrfs partition. - """ - fs = "%s/fs.%s" % (cr_workdir, self.fstype) - - dd_cmd = "dd if=/dev/zero of=%s bs=1M seek=%d count=0" % \ - (fs, self.size) - rc, out = exec_cmd(dd_cmd) - - mkfs_cmd = "mkfs.%s -b %d %s" % (self.fstype, self.size * 1024, rootfs) - rc, out = exec_native_cmd(mkfs_cmd, native_sysroot) - - mkfs_cmd = "mkfs.%s -F %s %s" % (self.fstype, extra_imagecmd, fs) - rc, out = exec_native_cmd(mkfs_cmd, native_sysroot) - - self.source_file = fs - - return 0 - - def prepare_empty_partition_vfat(self, cr_workdir, oe_builddir, - native_sysroot): - """ - Prepare an empty vfat partition. - """ - fs = "%s/fs.%s" % (cr_workdir, self.fstype) - - blocks = self.size * 1024 - - dosfs_cmd = "mkdosfs -n boot -S 512 -C %s %d" % (fs, blocks) - exec_native_cmd(dosfs_cmd, native_sysroot) - - chmod_cmd = "chmod 644 %s" % fs - exec_cmd(chmod_cmd) - - self.source_file = fs - - return 0 - - def prepare_empty_partition_squashfs(self, cr_workdir, oe_builddir, - native_sysroot): - """ - Prepare an empty squashfs partition. - """ - msger.warning("Creating of an empty squashfs %s partition was attempted. " \ - "Proceeding as requested." % self.mountpoint) - - fs = "%s/fs_%s.%s" % (cr_workdir, self.label, self.fstype) - - # it is not possible to create a squashfs without source data, - # thus prepare an empty temp dir that is used as source - tmpdir = tempfile.mkdtemp() - - squashfs_cmd = "mksquashfs %s %s -noappend" % \ - (tmpdir, fs) - rc, out = exec_native_cmd(squashfs_cmd, native_sysroot) - - os.rmdir(tmpdir) - - # get the rootfs size in the right units for kickstart (Mb) - du_cmd = "du -Lbms %s" % fs - rc, out = exec_cmd(du_cmd) - fs_size = out.split()[0] - - self.size = fs_size - self.source_file = fs - - return 0 - - def prepare_swap_partition(self, cr_workdir, oe_builddir, native_sysroot): - """ - Prepare a swap partition. - """ - fs = "%s/fs.%s" % (cr_workdir, self.fstype) - - dd_cmd = "dd if=/dev/zero of=%s bs=1M seek=%d count=0" % \ - (fs, self.size) - rc, out = exec_cmd(dd_cmd) - - import uuid - label_str = "" - if self.label: - label_str = "-L %s" % self.label - mkswap_cmd = "mkswap %s -U %s %s" % (label_str, str(uuid.uuid1()), fs) - rc, out = exec_native_cmd(mkswap_cmd, native_sysroot) - - self.source_file = fs - - return 0 - -class Wic_Partition(Mic_Partition): - removedKeywords = Mic_Partition.removedKeywords - removedAttrs = Mic_Partition.removedAttrs - - def _getParser(self): - op = Mic_Partition._getParser(self) - # use specified source file to fill the partition - # and calculate partition size - op.add_option("--source", type="string", action="store", - dest="source", default=None) - # use specified rootfs path to fill the partition - op.add_option("--rootfs-dir", type="string", action="store", - dest="rootfs", default=None) - return op diff --git a/scripts/lib/mic/kickstart/custom_commands/wicboot.py b/scripts/lib/mic/kickstart/custom_commands/wicboot.py deleted file mode 100644 index ab8871de4e..0000000000 --- a/scripts/lib/mic/kickstart/custom_commands/wicboot.py +++ /dev/null @@ -1,57 +0,0 @@ -# ex:ts=4:sw=4:sts=4:et -# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- -# -# Copyright (c) 2014, Intel Corporation. -# All rights reserved. -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License version 2 as -# published by the Free Software Foundation. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., -# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. -# -# DESCRIPTION -# This module provides the OpenEmbedded bootloader object definitions. -# -# AUTHORS -# Tom Zanussi <tom.zanussi (at] linux.intel.com> -# - -from pykickstart.base import * -from pykickstart.errors import * -from pykickstart.options import * -from pykickstart.commands.bootloader import * - -from mic.kickstart.custom_commands.micboot import * - -class Wic_Bootloader(Mic_Bootloader): - def __init__(self, writePriority=10, appendLine="", driveorder=None, - forceLBA=False, location="", md5pass="", password="", - upgrade=False, menus=""): - Mic_Bootloader.__init__(self, writePriority, appendLine, driveorder, - forceLBA, location, md5pass, password, upgrade) - - self.source = "" - - def _getArgsAsStr(self): - retval = Mic_Bootloader._getArgsAsStr(self) - - if self.source: - retval += " --source=%s" % self.source - - return retval - - def _getParser(self): - op = Mic_Bootloader._getParser(self) - # use specified source plugin to implement bootloader-specific methods - op.add_option("--source", type="string", action="store", - dest="source", default=None) - return op - diff --git a/scripts/lib/mic/msger.py b/scripts/lib/mic/msger.py deleted file mode 100644 index 9afc85be93..0000000000 --- a/scripts/lib/mic/msger.py +++ /dev/null @@ -1,309 +0,0 @@ -#!/usr/bin/python -tt -# vim: ai ts=4 sts=4 et sw=4 -# -# Copyright (c) 2009, 2010, 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os,sys -import re -import time - -__ALL__ = ['set_mode', - 'get_loglevel', - 'set_loglevel', - 'set_logfile', - 'raw', - 'debug', - 'verbose', - 'info', - 'warning', - 'error', - 'ask', - 'pause', - ] - -# COLORs in ANSI -INFO_COLOR = 32 # green -WARN_COLOR = 33 # yellow -ERR_COLOR = 31 # red -ASK_COLOR = 34 # blue -NO_COLOR = 0 - -PREFIX_RE = re.compile('^<(.*?)>\s*(.*)', re.S) - -INTERACTIVE = True - -LOG_LEVEL = 1 -LOG_LEVELS = { - 'quiet': 0, - 'normal': 1, - 'verbose': 2, - 'debug': 3, - 'never': 4, - } - -LOG_FILE_FP = None -LOG_CONTENT = '' -CATCHERR_BUFFILE_FD = -1 -CATCHERR_BUFFILE_PATH = None -CATCHERR_SAVED_2 = -1 - -def _general_print(head, color, msg = None, stream = None, level = 'normal'): - global LOG_CONTENT - if not stream: - stream = sys.stdout - - if LOG_LEVELS[level] > LOG_LEVEL: - # skip - return - - # encode raw 'unicode' str to utf8 encoded str - if msg and isinstance(msg, unicode): - msg = msg.encode('utf-8', 'ignore') - - errormsg = '' - if CATCHERR_BUFFILE_FD > 0: - size = os.lseek(CATCHERR_BUFFILE_FD , 0, os.SEEK_END) - os.lseek(CATCHERR_BUFFILE_FD, 0, os.SEEK_SET) - errormsg = os.read(CATCHERR_BUFFILE_FD, size) - os.ftruncate(CATCHERR_BUFFILE_FD, 0) - - # append error msg to LOG - if errormsg: - LOG_CONTENT += errormsg - - # append normal msg to LOG - save_msg = msg.strip() if msg else None - if save_msg: - timestr = time.strftime("[%m/%d %H:%M:%S %Z] ", time.localtime()) - LOG_CONTENT += timestr + save_msg + '\n' - - if errormsg: - _color_print('', NO_COLOR, errormsg, stream, level) - - _color_print(head, color, msg, stream, level) - -def _color_print(head, color, msg, stream, level): - colored = True - if color == NO_COLOR or \ - not stream.isatty() or \ - os.getenv('ANSI_COLORS_DISABLED') is not None: - colored = False - - if head.startswith('\r'): - # need not \n at last - newline = False - else: - newline = True - - if colored: - head = '\033[%dm%s:\033[0m ' %(color, head) - if not newline: - # ESC cmd to clear line - head = '\033[2K' + head - else: - if head: - head += ': ' - if head.startswith('\r'): - head = head.lstrip() - newline = True - - if msg is not None: - if isinstance(msg, unicode): - msg = msg.encode('utf8', 'ignore') - - stream.write('%s%s' % (head, msg)) - if newline: - stream.write('\n') - - stream.flush() - -def _color_perror(head, color, msg, level = 'normal'): - if CATCHERR_BUFFILE_FD > 0: - _general_print(head, color, msg, sys.stdout, level) - else: - _general_print(head, color, msg, sys.stderr, level) - -def _split_msg(head, msg): - if isinstance(msg, list): - msg = '\n'.join(map(str, msg)) - - if msg.startswith('\n'): - # means print \n at first - msg = msg.lstrip() - head = '\n' + head - - elif msg.startswith('\r'): - # means print \r at first - msg = msg.lstrip() - head = '\r' + head - - m = PREFIX_RE.match(msg) - if m: - head += ' <%s>' % m.group(1) - msg = m.group(2) - - return head, msg - -def get_loglevel(): - return (k for k,v in LOG_LEVELS.items() if v==LOG_LEVEL).next() - -def set_loglevel(level): - global LOG_LEVEL - if level not in LOG_LEVELS: - # no effect - return - - LOG_LEVEL = LOG_LEVELS[level] - -def set_interactive(mode=True): - global INTERACTIVE - if mode: - INTERACTIVE = True - else: - INTERACTIVE = False - -def log(msg=''): - # log msg to LOG_CONTENT then save to logfile - global LOG_CONTENT - if msg: - LOG_CONTENT += msg - -def raw(msg=''): - _general_print('', NO_COLOR, msg) - -def info(msg): - head, msg = _split_msg('Info', msg) - _general_print(head, INFO_COLOR, msg) - -def verbose(msg): - head, msg = _split_msg('Verbose', msg) - _general_print(head, INFO_COLOR, msg, level = 'verbose') - -def warning(msg): - head, msg = _split_msg('Warning', msg) - _color_perror(head, WARN_COLOR, msg) - -def debug(msg): - head, msg = _split_msg('Debug', msg) - _color_perror(head, ERR_COLOR, msg, level = 'debug') - -def error(msg): - head, msg = _split_msg('Error', msg) - _color_perror(head, ERR_COLOR, msg) - sys.exit(1) - -def ask(msg, default=True): - _general_print('\rQ', ASK_COLOR, '') - try: - if default: - msg += '(Y/n) ' - else: - msg += '(y/N) ' - if INTERACTIVE: - while True: - repl = raw_input(msg) - if repl.lower() == 'y': - return True - elif repl.lower() == 'n': - return False - elif not repl.strip(): - # <Enter> - return default - - # else loop - else: - if default: - msg += ' Y' - else: - msg += ' N' - _general_print('', NO_COLOR, msg) - - return default - except KeyboardInterrupt: - sys.stdout.write('\n') - sys.exit(2) - -def choice(msg, choices, default=0): - if default >= len(choices): - return None - _general_print('\rQ', ASK_COLOR, '') - try: - msg += " [%s] " % '/'.join(choices) - if INTERACTIVE: - while True: - repl = raw_input(msg) - if repl in choices: - return repl - elif not repl.strip(): - return choices[default] - else: - msg += choices[default] - _general_print('', NO_COLOR, msg) - - return choices[default] - except KeyboardInterrupt: - sys.stdout.write('\n') - sys.exit(2) - -def pause(msg=None): - if INTERACTIVE: - _general_print('\rQ', ASK_COLOR, '') - if msg is None: - msg = 'press <ENTER> to continue ...' - raw_input(msg) - -def set_logfile(fpath): - global LOG_FILE_FP - - def _savelogf(): - if LOG_FILE_FP: - fp = open(LOG_FILE_FP, 'w') - fp.write(LOG_CONTENT) - fp.close() - - if LOG_FILE_FP is not None: - warning('duplicate log file configuration') - - LOG_FILE_FP = fpath - - import atexit - atexit.register(_savelogf) - -def enable_logstderr(fpath): - global CATCHERR_BUFFILE_FD - global CATCHERR_BUFFILE_PATH - global CATCHERR_SAVED_2 - - if os.path.exists(fpath): - os.remove(fpath) - CATCHERR_BUFFILE_PATH = fpath - CATCHERR_BUFFILE_FD = os.open(CATCHERR_BUFFILE_PATH, os.O_RDWR|os.O_CREAT) - CATCHERR_SAVED_2 = os.dup(2) - os.dup2(CATCHERR_BUFFILE_FD, 2) - -def disable_logstderr(): - global CATCHERR_BUFFILE_FD - global CATCHERR_BUFFILE_PATH - global CATCHERR_SAVED_2 - - raw(msg = None) # flush message buffer and print it. - os.dup2(CATCHERR_SAVED_2, 2) - os.close(CATCHERR_SAVED_2) - os.close(CATCHERR_BUFFILE_FD) - os.unlink(CATCHERR_BUFFILE_PATH) - CATCHERR_BUFFILE_FD = -1 - CATCHERR_BUFFILE_PATH = None - CATCHERR_SAVED_2 = -1 diff --git a/scripts/lib/mic/plugin.py b/scripts/lib/mic/plugin.py deleted file mode 100644 index f836950727..0000000000 --- a/scripts/lib/mic/plugin.py +++ /dev/null @@ -1,156 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os, sys - -from mic import msger -from mic import pluginbase -from mic.utils import errors -from mic.utils.oe.misc import * - -__ALL__ = ['PluginMgr', 'pluginmgr'] - -PLUGIN_TYPES = ["imager", "source"] # TODO "hook" - -PLUGIN_DIR = "/lib/mic/plugins" # relative to scripts -SCRIPTS_PLUGIN_DIR = "scripts" + PLUGIN_DIR - -class PluginMgr(object): - plugin_dirs = {} - - # make the manager class as singleton - _instance = None - def __new__(cls, *args, **kwargs): - if not cls._instance: - cls._instance = super(PluginMgr, cls).__new__(cls, *args, **kwargs) - - return cls._instance - - def __init__(self): - mic_path = os.path.dirname(__file__) - eos = mic_path.find('scripts') + len('scripts') - scripts_path = mic_path[:eos] - self.scripts_path = scripts_path - self.plugin_dir = scripts_path + PLUGIN_DIR - self.layers_path = None - - def _build_plugin_dir_list(self, dl, ptype): - if self.layers_path is None: - self.layers_path = get_bitbake_var("BBLAYERS") - layer_dirs = [] - - if self.layers_path is not None: - for layer_path in self.layers_path.split(): - path = os.path.join(layer_path, SCRIPTS_PLUGIN_DIR, ptype) - layer_dirs.append(path) - - path = os.path.join(dl, ptype) - layer_dirs.append(path) - - return layer_dirs - - def append_dirs(self, dirs): - for path in dirs: - self._add_plugindir(path) - - # load all the plugins AGAIN - self._load_all() - - def _add_plugindir(self, path): - path = os.path.abspath(os.path.expanduser(path)) - - if not os.path.isdir(path): - msger.debug("Plugin dir is not a directory or does not exist: %s"\ - % path) - return - - if path not in self.plugin_dirs: - self.plugin_dirs[path] = False - # the value True/False means "loaded" - - def _load_all(self): - for (pdir, loaded) in self.plugin_dirs.iteritems(): - if loaded: continue - - sys.path.insert(0, pdir) - for mod in [x[:-3] for x in os.listdir(pdir) if x.endswith(".py")]: - if mod and mod != '__init__': - if mod in sys.modules: - #self.plugin_dirs[pdir] = True - msger.warning("Module %s already exists, skip" % mod) - else: - try: - pymod = __import__(mod) - self.plugin_dirs[pdir] = True - msger.debug("Plugin module %s:%s imported"\ - % (mod, pymod.__file__)) - except ImportError, err: - msg = 'Failed to load plugin %s/%s: %s' \ - % (os.path.basename(pdir), mod, err) - msger.warning(msg) - - del(sys.path[0]) - - def get_plugins(self, ptype): - """ the return value is dict of name:class pairs """ - - if ptype not in PLUGIN_TYPES: - raise errors.CreatorError('%s is not valid plugin type' % ptype) - - plugins_dir = self._build_plugin_dir_list(self.plugin_dir, ptype) - - self.append_dirs(plugins_dir) - - return pluginbase.get_plugins(ptype) - - def get_source_plugins(self): - """ - Return list of available source plugins. - """ - plugins_dir = self._build_plugin_dir_list(self.plugin_dir, 'source') - - self.append_dirs(plugins_dir) - - plugins = [] - - for _source_name, klass in self.get_plugins('source').iteritems(): - plugins.append(_source_name) - - return plugins - - - def get_source_plugin_methods(self, source_name, methods): - """ - The methods param is a dict with the method names to find. On - return, the dict values will be filled in with pointers to the - corresponding methods. If one or more methods are not found, - None is returned. - """ - return_methods = None - for _source_name, klass in self.get_plugins('source').iteritems(): - if _source_name == source_name: - for _method_name in methods.keys(): - if not hasattr(klass, _method_name): - msger.warning("Unimplemented %s source interface for: %s"\ - % (_method_name, _source_name)) - return None - func = getattr(klass, _method_name) - methods[_method_name] = func - return_methods = methods - return return_methods - -pluginmgr = PluginMgr() diff --git a/scripts/lib/mic/pluginbase.py b/scripts/lib/mic/pluginbase.py deleted file mode 100644 index 9cf4c628d1..0000000000 --- a/scripts/lib/mic/pluginbase.py +++ /dev/null @@ -1,149 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os -import shutil -from mic import msger -from mic.utils import errors - -class _Plugin(object): - class __metaclass__(type): - def __init__(cls, name, bases, attrs): - if not hasattr(cls, 'plugins'): - cls.plugins = {} - - elif 'mic_plugin_type' in attrs: - if attrs['mic_plugin_type'] not in cls.plugins: - cls.plugins[attrs['mic_plugin_type']] = {} - - elif hasattr(cls, 'mic_plugin_type') and 'name' in attrs: - cls.plugins[cls.mic_plugin_type][attrs['name']] = cls - - def show_plugins(cls): - for cls in cls.plugins[cls.mic_plugin_type]: - print cls - - def get_plugins(cls): - return cls.plugins - -class ImagerPlugin(_Plugin): - mic_plugin_type = "imager" - - @classmethod - def check_image_exists(self, destdir, apacking=None, - images=(), - release=None): - - # if it's a packing file, reset images - if apacking: - images = [apacking] - - # release option will override images - if release is not None: - images = [os.path.basename(destdir.rstrip('/'))] - destdir = os.path.dirname(destdir.rstrip('/')) - - for name in images: - if not name: - continue - - image = os.path.join(destdir, name) - if not os.path.exists(image): - continue - - if msger.ask("Target image/dir: %s already exists, " - "clean up and continue?" % image): - if os.path.isdir(image): - shutil.rmtree(image) - else: - os.unlink(image) - else: - raise errors.Abort("Cancled") - - def do_create(self): - pass - - def do_chroot(self): - pass - -class SourcePlugin(_Plugin): - mic_plugin_type = "source" - """ - The methods that can be implemented by --source plugins. - - Any methods not implemented in a subclass inherit these. - """ - - @classmethod - def do_install_disk(self, disk, disk_name, cr, workdir, oe_builddir, - bootimg_dir, kernel_dir, native_sysroot): - """ - Called after all partitions have been prepared and assembled into a - disk image. This provides a hook to allow finalization of a - disk image e.g. to write an MBR to it. - """ - msger.debug("SourcePlugin: do_install_disk: disk: %s" % disk_name) - - @classmethod - def do_stage_partition(self, part, cr, workdir, oe_builddir, bootimg_dir, - kernel_dir, native_sysroot): - """ - Special content staging hook called before do_prepare_partition(), - normally empty. - - Typically, a partition will just use the passed-in parame e.g - straight bootimg_dir, etc, but in some cases, things need to - be more tailored e.g. to use a deploy dir + /boot, etc. This - hook allows those files to be staged in a customized fashion. - Not that get_bitbake_var() allows you to acces non-standard - variables that you might want to use for this. - """ - msger.debug("SourcePlugin: do_stage_partition: part: %s" % part) - - @classmethod - def do_configure_partition(self, part, cr, cr_workdir, oe_builddir, - bootimg_dir, kernel_dir, native_sysroot): - """ - Called before do_prepare_partition(), typically used to create - custom configuration files for a partition, for example - syslinux or grub config files. - """ - msger.debug("SourcePlugin: do_configure_partition: part: %s" % part) - - @classmethod - def do_prepare_partition(self, part, cr, cr_workdir, oe_builddir, bootimg_dir, - kernel_dir, rootfs_dir, native_sysroot): - """ - Called to do the actual content population for a partition i.e. it - 'prepares' the partition to be incorporated into the image. - """ - msger.debug("SourcePlugin: do_prepare_partition: part: %s" % part) - -class BackendPlugin(_Plugin): - mic_plugin_type="backend" - - def addRepository(self): - pass - -def get_plugins(typen): - ps = ImagerPlugin.get_plugins() - if typen in ps: - return ps[typen] - else: - return None - -__all__ = ['ImagerPlugin', 'BackendPlugin', 'SourcePlugin', 'get_plugins'] diff --git a/scripts/lib/mic/plugins/backend/yumpkgmgr.py b/scripts/lib/mic/plugins/backend/yumpkgmgr.py deleted file mode 100644 index 955f813109..0000000000 --- a/scripts/lib/mic/plugins/backend/yumpkgmgr.py +++ /dev/null @@ -1,490 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2007 Red Hat Inc. -# Copyright (c) 2010, 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os, sys -import re -import tempfile -import glob -from string import Template - -import rpmUtils -import yum - -from mic import msger -from mic.kickstart import ksparser -from mic.utils import misc, rpmmisc -from mic.utils.grabber import TextProgress -from mic.utils.proxy import get_proxy_for -from mic.utils.errors import CreatorError -from mic.imager.baseimager import BaseImageCreator - -YUMCONF_TEMP = """[main] -installroot=$installroot -cachedir=/var/cache/yum -persistdir=/var/lib/yum -plugins=0 -reposdir= -failovermethod=priority -http_caching=packages -sslverify=1 -""" - -class MyYumRepository(yum.yumRepo.YumRepository): - def __del__(self): - pass - - def dirSetup(self): - super(MyYumRepository, self).dirSetup() - # relocate package dir - pkgdir = os.path.join(self.basecachedir, 'packages', self.id) - self.setAttribute('_dir_setup_pkgdir', pkgdir) - self._dirSetupMkdir_p(self.pkgdir) - - def _getFile(self, url=None, - relative=None, - local=None, - start=None, - end=None, - copy_local=None, - checkfunc=None, - text=None, - reget='simple', - cache=True, - size=None): - - m2c_connection = None - if not self.sslverify: - try: - import M2Crypto - m2c_connection = M2Crypto.SSL.Connection.clientPostConnectionCheck - M2Crypto.SSL.Connection.clientPostConnectionCheck = None - except ImportError, err: - raise CreatorError("%s, please try to install python-m2crypto" % str(err)) - - proxy = None - if url: - proxy = get_proxy_for(url) - else: - proxy = get_proxy_for(self.urls[0]) - - if proxy: - self.proxy = str(proxy) - - size = int(size) if size else None - rvalue = super(MyYumRepository, self)._getFile(url, - relative, - local, - start, - end, - copy_local, - checkfunc, - text, - reget, - cache, - size) - - if m2c_connection and \ - not M2Crypto.SSL.Connection.clientPostConnectionCheck: - M2Crypto.SSL.Connection.clientPostConnectionCheck = m2c_connection - - return rvalue - -from mic.pluginbase import BackendPlugin -class Yum(BackendPlugin, yum.YumBase): - name = 'yum' - - def __init__(self, target_arch, instroot, cachedir): - yum.YumBase.__init__(self) - - self.cachedir = cachedir - self.instroot = instroot - self.target_arch = target_arch - - if self.target_arch: - if not rpmUtils.arch.arches.has_key(self.target_arch): - rpmUtils.arch.arches["armv7hl"] = "noarch" - rpmUtils.arch.arches["armv7tnhl"] = "armv7nhl" - rpmUtils.arch.arches["armv7tnhl"] = "armv7thl" - rpmUtils.arch.arches["armv7thl"] = "armv7hl" - rpmUtils.arch.arches["armv7nhl"] = "armv7hl" - self.arch.setup_arch(self.target_arch) - - self.__pkgs_license = {} - self.__pkgs_content = {} - self.__pkgs_vcsinfo = {} - - self.install_debuginfo = False - - def doFileLogSetup(self, uid, logfile): - # don't do the file log for the livecd as it can lead to open fds - # being left and an inability to clean up after ourself - pass - - def close(self): - try: - os.unlink(self.confpath) - os.unlink(self.conf.installroot + "/yum.conf") - except: - pass - - if self.ts: - self.ts.close() - self._delRepos() - self._delSacks() - yum.YumBase.close(self) - self.closeRpmDB() - - if not os.path.exists("/etc/fedora-release") and \ - not os.path.exists("/etc/meego-release"): - for i in range(3, os.sysconf("SC_OPEN_MAX")): - try: - os.close(i) - except: - pass - - def __del__(self): - pass - - def _writeConf(self, confpath, installroot): - conf = Template(YUMCONF_TEMP).safe_substitute(installroot=installroot) - - f = file(confpath, "w+") - f.write(conf) - f.close() - - os.chmod(confpath, 0644) - - def _cleanupRpmdbLocks(self, installroot): - # cleans up temporary files left by bdb so that differing - # versions of rpm don't cause problems - for f in glob.glob(installroot + "/var/lib/rpm/__db*"): - os.unlink(f) - - def setup(self): - # create yum.conf - (fn, self.confpath) = tempfile.mkstemp(dir=self.cachedir, - prefix='yum.conf-') - os.close(fn) - self._writeConf(self.confpath, self.instroot) - self._cleanupRpmdbLocks(self.instroot) - # do setup - self.doConfigSetup(fn = self.confpath, root = self.instroot) - self.conf.cache = 0 - self.doTsSetup() - self.doRpmDBSetup() - self.doRepoSetup() - self.doSackSetup() - - def preInstall(self, pkg): - # FIXME: handle pre-install package - return None - - def selectPackage(self, pkg): - """Select a given package. - Can be specified with name.arch or name* - """ - - try: - self.install(pattern = pkg) - return None - except yum.Errors.InstallError: - return "No package(s) available to install" - except yum.Errors.RepoError, e: - raise CreatorError("Unable to download from repo : %s" % (e,)) - except yum.Errors.YumBaseError, e: - raise CreatorError("Unable to install: %s" % (e,)) - - def deselectPackage(self, pkg): - """Deselect package. Can be specified as name.arch or name* - """ - - sp = pkg.rsplit(".", 2) - txmbrs = [] - if len(sp) == 2: - txmbrs = self.tsInfo.matchNaevr(name=sp[0], arch=sp[1]) - - if len(txmbrs) == 0: - exact, match, unmatch = yum.packages.parsePackages( - self.pkgSack.returnPackages(), - [pkg], - casematch=1) - for p in exact + match: - txmbrs.append(p) - - if len(txmbrs) > 0: - for x in txmbrs: - self.tsInfo.remove(x.pkgtup) - # we also need to remove from the conditionals - # dict so that things don't get pulled back in as a result - # of them. yes, this is ugly. conditionals should die. - for req, pkgs in self.tsInfo.conditionals.iteritems(): - if x in pkgs: - pkgs.remove(x) - self.tsInfo.conditionals[req] = pkgs - else: - msger.warning("No such package %s to remove" %(pkg,)) - - def selectGroup(self, grp, include = ksparser.GROUP_DEFAULT): - try: - yum.YumBase.selectGroup(self, grp) - if include == ksparser.GROUP_REQUIRED: - for p in grp.default_packages.keys(): - self.deselectPackage(p) - - elif include == ksparser.GROUP_ALL: - for p in grp.optional_packages.keys(): - self.selectPackage(p) - - return None - except (yum.Errors.InstallError, yum.Errors.GroupsError), e: - return e - except yum.Errors.RepoError, e: - raise CreatorError("Unable to download from repo : %s" % (e,)) - except yum.Errors.YumBaseError, e: - raise CreatorError("Unable to install: %s" % (e,)) - - def addRepository(self, name, url = None, mirrorlist = None, proxy = None, - proxy_username = None, proxy_password = None, - inc = None, exc = None, ssl_verify=True, nocache=False, - cost = None, priority=None): - # TODO: Handle priority attribute for repos - def _varSubstitute(option): - # takes a variable and substitutes like yum configs do - option = option.replace("$basearch", rpmUtils.arch.getBaseArch()) - option = option.replace("$arch", rpmUtils.arch.getCanonArch()) - return option - - repo = MyYumRepository(name) - - # Set proxy - repo.proxy = proxy - repo.proxy_username = proxy_username - repo.proxy_password = proxy_password - - if url: - repo.baseurl.append(_varSubstitute(url)) - - # check LICENSE files - if not rpmmisc.checkRepositoryEULA(name, repo): - msger.warning('skip repo:%s for failed EULA confirmation' % name) - return None - - if mirrorlist: - repo.mirrorlist = _varSubstitute(mirrorlist) - - conf = yum.config.RepoConf() - for k, v in conf.iteritems(): - if v or not hasattr(repo, k): - repo.setAttribute(k, v) - - repo.sslverify = ssl_verify - repo.cache = not nocache - - repo.basecachedir = self.cachedir - repo.base_persistdir = self.conf.persistdir - repo.failovermethod = "priority" - repo.metadata_expire = 0 - # Enable gpg check for verifying corrupt packages - repo.gpgcheck = 1 - repo.enable() - repo.setup(0) - self.repos.add(repo) - if cost: - repo.cost = cost - - msger.verbose('repo: %s was added' % name) - return repo - - def installLocal(self, pkg, po=None, updateonly=False): - ts = rpmUtils.transaction.initReadOnlyTransaction() - try: - hdr = rpmUtils.miscutils.hdrFromPackage(ts, pkg) - except rpmUtils.RpmUtilsError, e: - raise yum.Errors.MiscError, \ - 'Could not open local rpm file: %s: %s' % (pkg, e) - - self.deselectPackage(hdr['name']) - yum.YumBase.installLocal(self, pkg, po, updateonly) - - def installHasFile(self, file): - provides_pkg = self.whatProvides(file, None, None) - dlpkgs = map( - lambda x: x.po, - filter( - lambda txmbr: txmbr.ts_state in ("i", "u"), - self.tsInfo.getMembers())) - - for p in dlpkgs: - for q in provides_pkg: - if (p == q): - return True - - return False - - def runInstall(self, checksize = 0): - os.environ["HOME"] = "/" - os.environ["LD_PRELOAD"] = "" - try: - (res, resmsg) = self.buildTransaction() - except yum.Errors.RepoError, e: - raise CreatorError("Unable to download from repo : %s" %(e,)) - - if res != 2: - raise CreatorError("Failed to build transaction : %s" \ - % str.join("\n", resmsg)) - - dlpkgs = map( - lambda x: x.po, - filter( - lambda txmbr: txmbr.ts_state in ("i", "u"), - self.tsInfo.getMembers())) - - # record all pkg and the content - for pkg in dlpkgs: - pkg_long_name = misc.RPM_FMT % { - 'name': pkg.name, - 'arch': pkg.arch, - 'version': pkg.version, - 'release': pkg.release - } - self.__pkgs_content[pkg_long_name] = pkg.files - license = pkg.license - if license in self.__pkgs_license.keys(): - self.__pkgs_license[license].append(pkg_long_name) - else: - self.__pkgs_license[license] = [pkg_long_name] - - total_count = len(dlpkgs) - cached_count = 0 - download_total_size = sum(map(lambda x: int(x.packagesize), dlpkgs)) - - msger.info("\nChecking packages cached ...") - for po in dlpkgs: - local = po.localPkg() - repo = filter(lambda r: r.id == po.repoid, self.repos.listEnabled())[0] - if not repo.cache and os.path.exists(local): - os.unlink(local) - if not os.path.exists(local): - continue - if not self.verifyPkg(local, po, False): - msger.warning("Package %s is damaged: %s" \ - % (os.path.basename(local), local)) - else: - download_total_size -= int(po.packagesize) - cached_count +=1 - - cache_avail_size = misc.get_filesystem_avail(self.cachedir) - if cache_avail_size < download_total_size: - raise CreatorError("No enough space used for downloading.") - - # record the total size of installed pkgs - pkgs_total_size = 0L - for x in dlpkgs: - if hasattr(x, 'installedsize'): - pkgs_total_size += int(x.installedsize) - else: - pkgs_total_size += int(x.size) - - # check needed size before actually download and install - if checksize and pkgs_total_size > checksize: - raise CreatorError("No enough space used for installing, " - "please resize partition size in ks file") - - msger.info("Packages: %d Total, %d Cached, %d Missed" \ - % (total_count, cached_count, total_count - cached_count)) - - try: - repos = self.repos.listEnabled() - for repo in repos: - repo.setCallback(TextProgress(total_count - cached_count)) - - self.downloadPkgs(dlpkgs) - # FIXME: sigcheck? - - self.initActionTs() - self.populateTs(keepold=0) - - deps = self.ts.check() - if len(deps) != 0: - # This isn't fatal, Ubuntu has this issue but it is ok. - msger.debug(deps) - msger.warning("Dependency check failed!") - - rc = self.ts.order() - if rc != 0: - raise CreatorError("ordering packages for installation failed") - - # FIXME: callback should be refactored a little in yum - cb = rpmmisc.RPMInstallCallback(self.ts) - cb.tsInfo = self.tsInfo - cb.filelog = False - - msger.warning('\nCaution, do NOT interrupt the installation, ' - 'else mic cannot finish the cleanup.') - - installlogfile = "%s/__catched_stderr.buf" % (self.instroot) - msger.enable_logstderr(installlogfile) - self.runTransaction(cb) - self._cleanupRpmdbLocks(self.conf.installroot) - - except rpmUtils.RpmUtilsError, e: - raise CreatorError("mic does NOT support delta rpm: %s" % e) - except yum.Errors.RepoError, e: - raise CreatorError("Unable to download from repo : %s" % e) - except yum.Errors.YumBaseError, e: - raise CreatorError("Unable to install: %s" % e) - finally: - msger.disable_logstderr() - - def getVcsInfo(self): - return self.__pkgs_vcsinfo - - def getAllContent(self): - return self.__pkgs_content - - def getPkgsLicense(self): - return self.__pkgs_license - - def getFilelist(self, pkgname): - if not pkgname: - return None - - pkg = filter(lambda txmbr: txmbr.po.name == pkgname, self.tsInfo.getMembers()) - if not pkg: - return None - return pkg[0].po.filelist - - def package_url(self, pkgname): - pkgs = self.pkgSack.searchNevra(name=pkgname) - if pkgs: - proxy = None - proxies = None - url = pkgs[0].remote_url - repoid = pkgs[0].repoid - repos = filter(lambda r: r.id == repoid, self.repos.listEnabled()) - - if repos: - proxy = repos[0].proxy - if not proxy: - proxy = get_proxy_for(url) - if proxy: - proxies = {str(url.split(':')[0]): str(proxy)} - - return (url, proxies) - - return (None, None) diff --git a/scripts/lib/mic/plugins/backend/zypppkgmgr.py b/scripts/lib/mic/plugins/backend/zypppkgmgr.py deleted file mode 100755 index c760859832..0000000000 --- a/scripts/lib/mic/plugins/backend/zypppkgmgr.py +++ /dev/null @@ -1,973 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2010, 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os -import shutil -import urlparse -import rpm - -import zypp -if not hasattr(zypp, 'PoolQuery') or \ - not hasattr(zypp.RepoManager, 'loadSolvFile'): - raise ImportError("python-zypp in host system cannot support PoolQuery or " - "loadSolvFile interface, please update it to enhanced " - "version which can be found in download.tizen.org/tools") - -from mic import msger -from mic.kickstart import ksparser -from mic.utils import misc, rpmmisc, runner, fs_related -from mic.utils.grabber import myurlgrab, TextProgress -from mic.utils.proxy import get_proxy_for -from mic.utils.errors import CreatorError, RepoError, RpmError -from mic.imager.baseimager import BaseImageCreator - -class RepositoryStub: - def __init__(self): - self.name = None - self.baseurl = [] - self.mirrorlist = None - self.proxy = None - self.proxy_username = None - self.proxy_password = None - self.nocache = False - - self.enabled = True - self.autorefresh = True - self.keeppackages = True - self.priority = None - -from mic.pluginbase import BackendPlugin -class Zypp(BackendPlugin): - name = 'zypp' - - def __init__(self, target_arch, instroot, cachedir): - self.cachedir = cachedir - self.instroot = instroot - self.target_arch = target_arch - - self.__pkgs_license = {} - self.__pkgs_content = {} - self.__pkgs_vcsinfo = {} - self.repos = [] - self.to_deselect = [] - self.localpkgs = {} - self.repo_manager = None - self.repo_manager_options = None - self.Z = None - self.ts = None - self.ts_pre = None - self.incpkgs = {} - self.excpkgs = {} - self.pre_pkgs = [] - self.probFilterFlags = [ rpm.RPMPROB_FILTER_OLDPACKAGE, - rpm.RPMPROB_FILTER_REPLACEPKG ] - - self.has_prov_query = True - self.install_debuginfo = False - - def doFileLogSetup(self, uid, logfile): - # don't do the file log for the livecd as it can lead to open fds - # being left and an inability to clean up after ourself - pass - - def closeRpmDB(self): - pass - - def close(self): - if self.ts: - self.ts.closeDB() - self.ts = None - - if self.ts_pre: - self.ts_pre.closeDB() - self.ts = None - - self.closeRpmDB() - - if not os.path.exists("/etc/fedora-release") and \ - not os.path.exists("/etc/meego-release"): - for i in range(3, os.sysconf("SC_OPEN_MAX")): - try: - os.close(i) - except: - pass - - def __del__(self): - self.close() - - def _cleanupRpmdbLocks(self, installroot): - # cleans up temporary files left by bdb so that differing - # versions of rpm don't cause problems - import glob - for f in glob.glob(installroot + "/var/lib/rpm/__db*"): - os.unlink(f) - - def _cleanupZyppJunk(self, installroot): - try: - shutil.rmtree(os.path.join(installroot, '.zypp')) - except: - pass - - def setup(self): - self._cleanupRpmdbLocks(self.instroot) - - def whatObsolete(self, pkg): - query = zypp.PoolQuery() - query.addKind(zypp.ResKind.package) - query.addAttribute(zypp.SolvAttr.obsoletes, pkg) - query.setMatchExact() - for pi in query.queryResults(self.Z.pool()): - return pi - return None - - def _zyppQueryPackage(self, pkg): - query = zypp.PoolQuery() - query.addKind(zypp.ResKind.package) - query.addAttribute(zypp.SolvAttr.name,pkg) - query.setMatchExact() - for pi in query.queryResults(self.Z.pool()): - return pi - return None - - def _splitPkgString(self, pkg): - sp = pkg.rsplit(".",1) - name = sp[0] - arch = None - if len(sp) == 2: - arch = sp[1] - sysarch = zypp.Arch(self.target_arch) - if not zypp.Arch(arch).compatible_with (sysarch): - arch = None - name = ".".join(sp) - return name, arch - - def selectPackage(self, pkg): - """Select a given package or package pattern, can be specified - with name.arch or name* or *name - """ - - if not self.Z: - self.__initialize_zypp() - - def markPoolItem(obs, pi): - if obs == None: - pi.status().setToBeInstalled (zypp.ResStatus.USER) - else: - obs.status().setToBeInstalled (zypp.ResStatus.USER) - - def cmpEVR(p1, p2): - # compare criterion: arch compatibility first, then repo - # priority, and version last - a1 = p1.arch() - a2 = p2.arch() - if str(a1) != str(a2): - if a1.compatible_with(a2): - return -1 - else: - return 1 - # Priority of a repository is an integer value between 0 (the - # highest priority) and 99 (the lowest priority) - pr1 = int(p1.repoInfo().priority()) - pr2 = int(p2.repoInfo().priority()) - if pr1 > pr2: - return -1 - elif pr1 < pr2: - return 1 - - ed1 = p1.edition() - ed2 = p2.edition() - (e1, v1, r1) = map(str, [ed1.epoch(), ed1.version(), ed1.release()]) - (e2, v2, r2) = map(str, [ed2.epoch(), ed2.version(), ed2.release()]) - return rpm.labelCompare((e1, v1, r1), (e2, v2, r2)) - - found = False - startx = pkg.startswith("*") - endx = pkg.endswith("*") - ispattern = startx or endx - name, arch = self._splitPkgString(pkg) - - q = zypp.PoolQuery() - q.addKind(zypp.ResKind.package) - - if ispattern: - if startx and not endx: - pattern = '%s$' % (pkg[1:]) - if endx and not startx: - pattern = '^%s' % (pkg[0:-1]) - if endx and startx: - pattern = '%s' % (pkg[1:-1]) - q.setMatchRegex() - q.addAttribute(zypp.SolvAttr.name,pattern) - - elif arch: - q.setMatchExact() - q.addAttribute(zypp.SolvAttr.name,name) - - else: - q.setMatchExact() - q.addAttribute(zypp.SolvAttr.name,pkg) - - for pitem in sorted( - q.queryResults(self.Z.pool()), - cmp=lambda x,y: cmpEVR(zypp.asKindPackage(x), zypp.asKindPackage(y)), - reverse=True): - item = zypp.asKindPackage(pitem) - if item.name() in self.excpkgs.keys() and \ - self.excpkgs[item.name()] == item.repoInfo().name(): - continue - if item.name() in self.incpkgs.keys() and \ - self.incpkgs[item.name()] != item.repoInfo().name(): - continue - - found = True - obspkg = self.whatObsolete(item.name()) - if arch: - if arch == str(item.arch()): - item.status().setToBeInstalled (zypp.ResStatus.USER) - else: - markPoolItem(obspkg, pitem) - if not ispattern: - break - - # Can't match using package name, then search from packge - # provides infomation - if found == False and not ispattern: - q.addAttribute(zypp.SolvAttr.provides, pkg) - q.addAttribute(zypp.SolvAttr.name,'') - - for pitem in sorted( - q.queryResults(self.Z.pool()), - cmp=lambda x,y: cmpEVR(zypp.asKindPackage(x), zypp.asKindPackage(y)), - reverse=True): - item = zypp.asKindPackage(pitem) - if item.name() in self.excpkgs.keys() and \ - self.excpkgs[item.name()] == item.repoInfo().name(): - continue - if item.name() in self.incpkgs.keys() and \ - self.incpkgs[item.name()] != item.repoInfo().name(): - continue - - found = True - obspkg = self.whatObsolete(item.name()) - markPoolItem(obspkg, pitem) - break - - if found: - return None - else: - raise CreatorError("Unable to find package: %s" % (pkg,)) - - def inDeselectPackages(self, pitem): - """check if specified pacakges are in the list of inDeselectPackages - """ - item = zypp.asKindPackage(pitem) - name = item.name() - for pkg in self.to_deselect: - startx = pkg.startswith("*") - endx = pkg.endswith("*") - ispattern = startx or endx - pkgname, pkgarch = self._splitPkgString(pkg) - if not ispattern: - if pkgarch: - if name == pkgname and str(item.arch()) == pkgarch: - return True; - else: - if name == pkgname: - return True; - else: - if startx and name.endswith(pkg[1:]): - return True; - if endx and name.startswith(pkg[:-1]): - return True; - - return False; - - def deselectPackage(self, pkg): - """collect packages should not be installed""" - self.to_deselect.append(pkg) - - def selectGroup(self, grp, include = ksparser.GROUP_DEFAULT): - if not self.Z: - self.__initialize_zypp() - found = False - q=zypp.PoolQuery() - q.addKind(zypp.ResKind.pattern) - for pitem in q.queryResults(self.Z.pool()): - item = zypp.asKindPattern(pitem) - summary = "%s" % item.summary() - name = "%s" % item.name() - if name == grp or summary == grp: - found = True - pitem.status().setToBeInstalled (zypp.ResStatus.USER) - break - - if found: - if include == ksparser.GROUP_REQUIRED: - map( - lambda p: self.deselectPackage(p), - grp.default_packages.keys()) - - return None - else: - raise CreatorError("Unable to find pattern: %s" % (grp,)) - - def addRepository(self, name, - url = None, - mirrorlist = None, - proxy = None, - proxy_username = None, - proxy_password = None, - inc = None, - exc = None, - ssl_verify = True, - nocache = False, - cost=None, - priority=None): - # TODO: Handle cost attribute for repos - - if not self.repo_manager: - self.__initialize_repo_manager() - - if not proxy and url: - proxy = get_proxy_for(url) - - repo = RepositoryStub() - repo.name = name - repo.id = name - repo.proxy = proxy - repo.proxy_username = proxy_username - repo.proxy_password = proxy_password - repo.ssl_verify = ssl_verify - repo.nocache = nocache - repo.baseurl.append(url) - if inc: - for pkg in inc: - self.incpkgs[pkg] = name - if exc: - for pkg in exc: - self.excpkgs[pkg] = name - - # check LICENSE files - if not rpmmisc.checkRepositoryEULA(name, repo): - msger.warning('skip repo:%s for failed EULA confirmation' % name) - return None - - if mirrorlist: - repo.mirrorlist = mirrorlist - - # Enable gpg check for verifying corrupt packages - repo.gpgcheck = 1 - if priority is not None: - # priority 0 has issue in RepoInfo.setPriority - repo.priority = priority + 1 - - try: - repo_info = zypp.RepoInfo() - repo_info.setAlias(repo.name) - repo_info.setName(repo.name) - repo_info.setEnabled(repo.enabled) - repo_info.setAutorefresh(repo.autorefresh) - repo_info.setKeepPackages(repo.keeppackages) - baseurl = zypp.Url(repo.baseurl[0]) - if not ssl_verify: - baseurl.setQueryParam("ssl_verify", "no") - if proxy: - scheme, host, path, parm, query, frag = urlparse.urlparse(proxy) - - proxyinfo = host.split(":") - host = proxyinfo[0] - - port = "80" - if len(proxyinfo) > 1: - port = proxyinfo[1] - - if proxy.startswith("socks") and len(proxy.rsplit(':', 1)) == 2: - host = proxy.rsplit(':', 1)[0] - port = proxy.rsplit(':', 1)[1] - - baseurl.setQueryParam ("proxy", host) - baseurl.setQueryParam ("proxyport", port) - - repo.baseurl[0] = baseurl.asCompleteString() - self.repos.append(repo) - - repo_info.addBaseUrl(baseurl) - - if repo.priority is not None: - repo_info.setPriority(repo.priority) - - # this hack is used to change zypp credential file location - # the default one is $HOME/.zypp, which cause conflicts when - # installing some basic packages, and the location doesn't - # have any interface actually, so use a tricky way anyway - homedir = None - if 'HOME' in os.environ: - homedir = os.environ['HOME'] - os.environ['HOME'] = '/' - else: - os.environ['HOME'] = '/' - - self.repo_manager.addRepository(repo_info) - - # save back the $HOME env - if homedir: - os.environ['HOME'] = homedir - else: - del os.environ['HOME'] - - self.__build_repo_cache(name) - - except RuntimeError, e: - raise CreatorError(str(e)) - - msger.verbose('repo: %s was added' % name) - return repo - - def installHasFile(self, file): - return False - - def preInstall(self, pkg): - self.pre_pkgs.append(pkg) - - def runInstall(self, checksize = 0): - os.environ["HOME"] = "/" - os.environ["LD_PRELOAD"] = "" - self.buildTransaction() - - todo = zypp.GetResolvablesToInsDel(self.Z.pool()) - installed_pkgs = todo._toInstall - dlpkgs = [] - for pitem in installed_pkgs: - if not zypp.isKindPattern(pitem) and \ - not self.inDeselectPackages(pitem): - item = zypp.asKindPackage(pitem) - dlpkgs.append(item) - - if not self.install_debuginfo or str(item.arch()) == "noarch": - continue - - dipkg = self._zyppQueryPackage("%s-debuginfo" % item.name()) - if dipkg: - ditem = zypp.asKindPackage(dipkg) - dlpkgs.append(ditem) - else: - msger.warning("No debuginfo rpm found for: %s" \ - % item.name()) - - # record all pkg and the content - localpkgs = self.localpkgs.keys() - for pkg in dlpkgs: - license = '' - if pkg.name() in localpkgs: - hdr = rpmmisc.readRpmHeader(self.ts, self.localpkgs[pkg.name()]) - pkg_long_name = misc.RPM_FMT % { - 'name': hdr['name'], - 'arch': hdr['arch'], - 'version': hdr['version'], - 'release': hdr['release'] - } - license = hdr['license'] - - else: - pkg_long_name = misc.RPM_FMT % { - 'name': pkg.name(), - 'arch': pkg.arch(), - 'version': pkg.edition().version(), - 'release': pkg.edition().release() - } - - license = pkg.license() - - if license in self.__pkgs_license.keys(): - self.__pkgs_license[license].append(pkg_long_name) - else: - self.__pkgs_license[license] = [pkg_long_name] - - total_count = len(dlpkgs) - cached_count = 0 - download_total_size = sum(map(lambda x: int(x.downloadSize()), dlpkgs)) - localpkgs = self.localpkgs.keys() - - msger.info("Checking packages cached ...") - for po in dlpkgs: - # Check if it is cached locally - if po.name() in localpkgs: - cached_count += 1 - else: - local = self.getLocalPkgPath(po) - name = str(po.repoInfo().name()) - try: - repo = filter(lambda r: r.name == name, self.repos)[0] - except IndexError: - repo = None - nocache = repo.nocache if repo else False - - if os.path.exists(local): - if nocache or self.checkPkg(local) !=0: - os.unlink(local) - else: - download_total_size -= int(po.downloadSize()) - cached_count += 1 - cache_avail_size = misc.get_filesystem_avail(self.cachedir) - if cache_avail_size < download_total_size: - raise CreatorError("No enough space used for downloading.") - - # record the total size of installed pkgs - install_total_size = sum(map(lambda x: int(x.installSize()), dlpkgs)) - # check needed size before actually download and install - - # FIXME: for multiple partitions for loop type, check fails - # skip the check temporarily - #if checksize and install_total_size > checksize: - # raise CreatorError("No enough space used for installing, " - # "please resize partition size in ks file") - - download_count = total_count - cached_count - msger.info("Packages: %d Total, %d Cached, %d Missed" \ - % (total_count, cached_count, download_count)) - - try: - if download_count > 0: - msger.info("Downloading packages ...") - self.downloadPkgs(dlpkgs, download_count) - - self.installPkgs(dlpkgs) - - except (RepoError, RpmError): - raise - except Exception, e: - raise CreatorError("Package installation failed: %s" % (e,)) - - def getVcsInfo(self): - if self.__pkgs_vcsinfo: - return - - if not self.ts: - self.__initialize_transaction() - - mi = self.ts.dbMatch() - for hdr in mi: - lname = misc.RPM_FMT % { - 'name': hdr['name'], - 'arch': hdr['arch'], - 'version': hdr['version'], - 'release': hdr['release'] - } - self.__pkgs_vcsinfo[lname] = hdr['VCS'] - - return self.__pkgs_vcsinfo - - def getAllContent(self): - if self.__pkgs_content: - return self.__pkgs_content - - if not self.ts: - self.__initialize_transaction() - - mi = self.ts.dbMatch() - for hdr in mi: - lname = misc.RPM_FMT % { - 'name': hdr['name'], - 'arch': hdr['arch'], - 'version': hdr['version'], - 'release': hdr['release'] - } - self.__pkgs_content[lname] = hdr['FILENAMES'] - - return self.__pkgs_content - - def getPkgsLicense(self): - return self.__pkgs_license - - def getFilelist(self, pkgname): - if not pkgname: - return None - - if not self.ts: - self.__initialize_transaction() - - mi = self.ts.dbMatch('name', pkgname) - for header in mi: - return header['FILENAMES'] - - def __initialize_repo_manager(self): - if self.repo_manager: - return - - # Clean up repo metadata - shutil.rmtree(self.cachedir + "/etc", ignore_errors = True) - shutil.rmtree(self.cachedir + "/solv", ignore_errors = True) - shutil.rmtree(self.cachedir + "/raw", ignore_errors = True) - - zypp.KeyRing.setDefaultAccept( zypp.KeyRing.ACCEPT_UNSIGNED_FILE - | zypp.KeyRing.ACCEPT_VERIFICATION_FAILED - | zypp.KeyRing.ACCEPT_UNKNOWNKEY - | zypp.KeyRing.TRUST_KEY_TEMPORARILY - ) - - self.repo_manager_options = \ - zypp.RepoManagerOptions(zypp.Pathname(self.instroot)) - - self.repo_manager_options.knownReposPath = \ - zypp.Pathname(self.cachedir + "/etc/zypp/repos.d") - - self.repo_manager_options.repoCachePath = \ - zypp.Pathname(self.cachedir) - - self.repo_manager_options.repoRawCachePath = \ - zypp.Pathname(self.cachedir + "/raw") - - self.repo_manager_options.repoSolvCachePath = \ - zypp.Pathname(self.cachedir + "/solv") - - self.repo_manager_options.repoPackagesCachePath = \ - zypp.Pathname(self.cachedir + "/packages") - - self.repo_manager = zypp.RepoManager(self.repo_manager_options) - - def __build_repo_cache(self, name): - repo = self.repo_manager.getRepositoryInfo(name) - if self.repo_manager.isCached(repo) or not repo.enabled(): - return - - msger.info('Refreshing repository: %s ...' % name) - self.repo_manager.buildCache(repo, zypp.RepoManager.BuildIfNeeded) - - def __initialize_zypp(self): - if self.Z: - return - - zconfig = zypp.ZConfig_instance() - - # Set system architecture - if self.target_arch: - zconfig.setSystemArchitecture(zypp.Arch(self.target_arch)) - - msger.info("zypp architecture is <%s>" % zconfig.systemArchitecture()) - - # repoPackagesCachePath is corrected by this - self.repo_manager = zypp.RepoManager(self.repo_manager_options) - repos = self.repo_manager.knownRepositories() - for repo in repos: - if not repo.enabled(): - continue - self.repo_manager.loadFromCache(repo) - - self.Z = zypp.ZYppFactory_instance().getZYpp() - self.Z.initializeTarget(zypp.Pathname(self.instroot)) - self.Z.target().load() - - def buildTransaction(self): - if not self.Z.resolver().resolvePool(): - probs = self.Z.resolver().problems() - - for problem in probs: - msger.warning("repo problem: %s, %s" \ - % (problem.description().decode("utf-8"), - problem.details().decode("utf-8"))) - - raise RepoError("found %d resolver problem, abort!" \ - % len(probs)) - - def getLocalPkgPath(self, po): - repoinfo = po.repoInfo() - cacheroot = repoinfo.packagesPath() - location= po.location() - rpmpath = str(location.filename()) - pkgpath = "%s/%s" % (cacheroot, os.path.basename(rpmpath)) - return pkgpath - - def installLocal(self, pkg, po=None, updateonly=False): - if not self.ts: - self.__initialize_transaction() - - solvfile = "%s/.solv" % (self.cachedir) - - rc, out = runner.runtool([fs_related.find_binary_path("rpms2solv"), - pkg]) - if rc == 0: - f = open(solvfile, "w+") - f.write(out) - f.close() - - warnmsg = self.repo_manager.loadSolvFile(solvfile, - os.path.basename(pkg)) - if warnmsg: - msger.warning(warnmsg) - - os.unlink(solvfile) - else: - msger.warning('Can not get %s solv data.' % pkg) - - hdr = rpmmisc.readRpmHeader(self.ts, pkg) - arch = zypp.Arch(hdr['arch']) - sysarch = zypp.Arch(self.target_arch) - - if arch.compatible_with (sysarch): - pkgname = hdr['name'] - self.localpkgs[pkgname] = pkg - self.selectPackage(pkgname) - msger.info("Marking %s to be installed" % (pkg)) - - else: - msger.warning("Cannot add package %s to transaction. " - "Not a compatible architecture: %s" \ - % (pkg, hdr['arch'])) - - def downloadPkgs(self, package_objects, count): - localpkgs = self.localpkgs.keys() - progress_obj = TextProgress(count) - - for po in package_objects: - if po.name() in localpkgs: - continue - - filename = self.getLocalPkgPath(po) - if os.path.exists(filename): - if self.checkPkg(filename) == 0: - continue - - dirn = os.path.dirname(filename) - if not os.path.exists(dirn): - os.makedirs(dirn) - - url = self.get_url(po) - proxies = self.get_proxies(po) - - try: - filename = myurlgrab(url, filename, proxies, progress_obj) - except CreatorError: - self.close() - raise - - def preinstallPkgs(self): - if not self.ts_pre: - self.__initialize_transaction() - - self.ts_pre.order() - cb = rpmmisc.RPMInstallCallback(self.ts_pre) - cb.headmsg = "Preinstall" - installlogfile = "%s/__catched_stderr.buf" % (self.instroot) - - # start to catch stderr output from librpm - msger.enable_logstderr(installlogfile) - - errors = self.ts_pre.run(cb.callback, '') - # stop catch - msger.disable_logstderr() - self.ts_pre.closeDB() - self.ts_pre = None - - if errors is not None: - if len(errors) == 0: - msger.warning('scriptlet or other non-fatal errors occurred ' - 'during transaction.') - - else: - for e in errors: - msger.warning(e[0]) - raise RepoError('Could not run transaction.') - - def installPkgs(self, package_objects): - if not self.ts: - self.__initialize_transaction() - - # clean rpm lock - self._cleanupRpmdbLocks(self.instroot) - self._cleanupZyppJunk(self.instroot) - # Set filters - probfilter = 0 - for flag in self.probFilterFlags: - probfilter |= flag - self.ts.setProbFilter(probfilter) - self.ts_pre.setProbFilter(probfilter) - - localpkgs = self.localpkgs.keys() - - for po in package_objects: - pkgname = po.name() - if pkgname in localpkgs: - rpmpath = self.localpkgs[pkgname] - else: - rpmpath = self.getLocalPkgPath(po) - - if not os.path.exists(rpmpath): - # Maybe it is a local repo - rpmuri = self.get_url(po) - if rpmuri.startswith("file:/"): - rpmpath = rpmuri[5:] - - if not os.path.exists(rpmpath): - raise RpmError("Error: %s doesn't exist" % rpmpath) - - h = rpmmisc.readRpmHeader(self.ts, rpmpath) - - if pkgname in self.pre_pkgs: - msger.verbose("pre-install package added: %s" % pkgname) - self.ts_pre.addInstall(h, rpmpath, 'u') - - self.ts.addInstall(h, rpmpath, 'u') - - unresolved_dependencies = self.ts.check() - if not unresolved_dependencies: - if self.pre_pkgs: - self.preinstallPkgs() - - self.ts.order() - cb = rpmmisc.RPMInstallCallback(self.ts) - installlogfile = "%s/__catched_stderr.buf" % (self.instroot) - - # start to catch stderr output from librpm - msger.enable_logstderr(installlogfile) - - errors = self.ts.run(cb.callback, '') - # stop catch - msger.disable_logstderr() - self.ts.closeDB() - self.ts = None - - if errors is not None: - if len(errors) == 0: - msger.warning('scriptlet or other non-fatal errors occurred ' - 'during transaction.') - - else: - for e in errors: - msger.warning(e[0]) - raise RepoError('Could not run transaction.') - - else: - for pkg, need, needflags, sense, key in unresolved_dependencies: - package = '-'.join(pkg) - - if needflags == rpm.RPMSENSE_LESS: - deppkg = ' < '.join(need) - elif needflags == rpm.RPMSENSE_EQUAL: - deppkg = ' = '.join(need) - elif needflags == rpm.RPMSENSE_GREATER: - deppkg = ' > '.join(need) - else: - deppkg = '-'.join(need) - - if sense == rpm.RPMDEP_SENSE_REQUIRES: - msger.warning("[%s] Requires [%s], which is not provided" \ - % (package, deppkg)) - - elif sense == rpm.RPMDEP_SENSE_CONFLICTS: - msger.warning("[%s] Conflicts with [%s]" %(package,deppkg)) - - raise RepoError("Unresolved dependencies, transaction failed.") - - def __initialize_transaction(self): - if not self.ts: - self.ts = rpm.TransactionSet(self.instroot) - # Set to not verify DSA signatures. - self.ts.setVSFlags(rpm._RPMVSF_NOSIGNATURES|rpm._RPMVSF_NODIGESTS) - - if not self.ts_pre: - self.ts_pre = rpm.TransactionSet(self.instroot) - # Just unpack the files, don't run scripts - self.ts_pre.setFlags(rpm.RPMTRANS_FLAG_ALLFILES | rpm.RPMTRANS_FLAG_NOSCRIPTS) - # Set to not verify DSA signatures. - self.ts_pre.setVSFlags(rpm._RPMVSF_NOSIGNATURES|rpm._RPMVSF_NODIGESTS) - - def checkPkg(self, pkg): - ret = 1 - if not os.path.exists(pkg): - return ret - ret = rpmmisc.checkRpmIntegrity('rpm', pkg) - if ret != 0: - msger.warning("package %s is damaged: %s" \ - % (os.path.basename(pkg), pkg)) - - return ret - - def _add_prob_flags(self, *flags): - for flag in flags: - if flag not in self.probFilterFlags: - self.probFilterFlags.append(flag) - - def get_proxies(self, pobj): - if not pobj: - return None - - proxy = None - proxies = None - repoinfo = pobj.repoInfo() - reponame = "%s" % repoinfo.name() - repos = filter(lambda r: r.name == reponame, self.repos) - repourl = str(repoinfo.baseUrls()[0]) - - if repos: - proxy = repos[0].proxy - if not proxy: - proxy = get_proxy_for(repourl) - if proxy: - proxies = {str(repourl.split(':')[0]): str(proxy)} - - return proxies - - def get_url(self, pobj): - if not pobj: - return None - - name = str(pobj.repoInfo().name()) - try: - repo = filter(lambda r: r.name == name, self.repos)[0] - except IndexError: - return None - - baseurl = repo.baseurl[0] - - index = baseurl.find("?") - if index > -1: - baseurl = baseurl[:index] - - location = pobj.location() - location = str(location.filename()) - if location.startswith("./"): - location = location[2:] - - return os.path.join(baseurl, location) - - def package_url(self, pkgname): - - def cmpEVR(p1, p2): - ed1 = p1.edition() - ed2 = p2.edition() - (e1, v1, r1) = map(str, [ed1.epoch(), ed1.version(), ed1.release()]) - (e2, v2, r2) = map(str, [ed2.epoch(), ed2.version(), ed2.release()]) - return rpm.labelCompare((e1, v1, r1), (e2, v2, r2)) - - if not self.Z: - self.__initialize_zypp() - - q = zypp.PoolQuery() - q.addKind(zypp.ResKind.package) - q.setMatchExact() - q.addAttribute(zypp.SolvAttr.name, pkgname) - items = sorted(q.queryResults(self.Z.pool()), - cmp=lambda x,y: cmpEVR(zypp.asKindPackage(x), zypp.asKindPackage(y)), - reverse=True) - - if items: - item = zypp.asKindPackage(items[0]) - url = self.get_url(item) - proxies = self.get_proxies(item) - return (url, proxies) - - return (None, None) diff --git a/scripts/lib/mic/plugins/hook/.py b/scripts/lib/mic/plugins/hook/.py deleted file mode 100644 index e69de29bb2..0000000000 --- a/scripts/lib/mic/plugins/hook/.py +++ /dev/null diff --git a/scripts/lib/mic/plugins/hook/empty_hook.py b/scripts/lib/mic/plugins/hook/empty_hook.py deleted file mode 100644 index 397585d8c1..0000000000 --- a/scripts/lib/mic/plugins/hook/empty_hook.py +++ /dev/null @@ -1,3 +0,0 @@ -#!/usr/bin/python - -# TODO: plugin base for hooks diff --git a/scripts/lib/mic/plugins/imager/direct_plugin.py b/scripts/lib/mic/plugins/imager/direct_plugin.py deleted file mode 100644 index fc7c10c3df..0000000000 --- a/scripts/lib/mic/plugins/imager/direct_plugin.py +++ /dev/null @@ -1,107 +0,0 @@ -# ex:ts=4:sw=4:sts=4:et -# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- -# -# Copyright (c) 2013, Intel Corporation. -# All rights reserved. -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License version 2 as -# published by the Free Software Foundation. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., -# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. -# -# DESCRIPTION -# This implements the 'direct' imager plugin class for 'wic', based -# loosely on the raw imager plugin from 'mic' -# -# AUTHORS -# Tom Zanussi <tom.zanussi (at] linux.intel.com> -# - -import os -import shutil -import re -import tempfile - -from mic import chroot, msger -from mic.utils import misc, fs_related, errors, runner, cmdln -from mic.conf import configmgr -from mic.plugin import pluginmgr -from mic.utils.partitionedfs import PartitionedMount - -import mic.imager.direct as direct -from mic.pluginbase import ImagerPlugin - -class DirectPlugin(ImagerPlugin): - name = 'direct' - - @classmethod - def __rootfs_dir_to_dict(self, rootfs_dirs): - """ - Gets a string that contain 'connection=dir' splitted by - space and return a dict - """ - krootfs_dir = {} - for rootfs_dir in rootfs_dirs.split(' '): - k, v = rootfs_dir.split('=') - krootfs_dir[k] = v - - return krootfs_dir - - @classmethod - def do_create(self, subcmd, opts, *args): - """ - Create direct image, called from creator as 'direct' cmd - """ - if len(args) != 9: - raise errors.Usage("Extra arguments given") - - staging_data_dir = args[0] - hdddir = args[1] - native_sysroot = args[2] - kernel_dir = args[3] - bootimg_dir = args[4] - rootfs_dir = args[5] - - creatoropts = configmgr.create - ksconf = args[6] - - image_output_dir = args[7] - oe_builddir = args[8] - - krootfs_dir = self.__rootfs_dir_to_dict(rootfs_dir) - - configmgr._ksconf = ksconf - - creator = direct.DirectImageCreator(oe_builddir, - image_output_dir, - krootfs_dir, - bootimg_dir, - kernel_dir, - native_sysroot, - hdddir, - staging_data_dir, - creatoropts, - None, - None, - None) - - try: - creator.mount(None, creatoropts["cachedir"]) - creator.install() - creator.configure(creatoropts["repomd"]) - creator.print_outimage_info() - - except errors.CreatorError: - raise - finally: - creator.cleanup() - - return 0 diff --git a/scripts/lib/mic/plugins/imager/fs_plugin.py b/scripts/lib/mic/plugins/imager/fs_plugin.py deleted file mode 100644 index 6bcaf00729..0000000000 --- a/scripts/lib/mic/plugins/imager/fs_plugin.py +++ /dev/null @@ -1,143 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os -import sys - -from mic import chroot, msger -from mic.utils import cmdln, misc, errors, fs_related -from mic.imager import fs -from mic.conf import configmgr -from mic.plugin import pluginmgr - -from mic.pluginbase import ImagerPlugin -class FsPlugin(ImagerPlugin): - name = 'fs' - - @classmethod - @cmdln.option("--include-src", - dest="include_src", - action="store_true", - default=False, - help="Generate a image with source rpms included") - def do_create(self, subcmd, opts, *args): - """${cmd_name}: create fs image - - Usage: - ${name} ${cmd_name} <ksfile> [OPTS] - - ${cmd_option_list} - """ - - if len(args) != 1: - raise errors.Usage("Extra arguments given") - - creatoropts = configmgr.create - ksconf = args[0] - - if creatoropts['runtime'] == 'bootstrap': - configmgr._ksconf = ksconf - rt_util.bootstrap_mic() - - recording_pkgs = [] - if len(creatoropts['record_pkgs']) > 0: - recording_pkgs = creatoropts['record_pkgs'] - - if creatoropts['release'] is not None: - if 'name' not in recording_pkgs: - recording_pkgs.append('name') - if 'vcs' not in recording_pkgs: - recording_pkgs.append('vcs') - - configmgr._ksconf = ksconf - - # Called After setting the configmgr._ksconf as the creatoropts['name'] is reset there. - if creatoropts['release'] is not None: - creatoropts['outdir'] = "%s/%s/images/%s/" % (creatoropts['outdir'], creatoropts['release'], creatoropts['name']) - - # try to find the pkgmgr - pkgmgr = None - backends = pluginmgr.get_plugins('backend') - if 'auto' == creatoropts['pkgmgr']: - for key in configmgr.prefer_backends: - if key in backends: - pkgmgr = backends[key] - break - else: - for key in backends.keys(): - if key == creatoropts['pkgmgr']: - pkgmgr = backends[key] - break - - if not pkgmgr: - raise errors.CreatorError("Can't find backend: %s, " - "available choices: %s" % - (creatoropts['pkgmgr'], - ','.join(backends.keys()))) - - creator = fs.FsImageCreator(creatoropts, pkgmgr) - creator._include_src = opts.include_src - - if len(recording_pkgs) > 0: - creator._recording_pkgs = recording_pkgs - - self.check_image_exists(creator.destdir, - creator.pack_to, - [creator.name], - creatoropts['release']) - - try: - creator.check_depend_tools() - creator.mount(None, creatoropts["cachedir"]) - creator.install() - #Download the source packages ###private options - if opts.include_src: - installed_pkgs = creator.get_installed_packages() - msger.info('--------------------------------------------------') - msger.info('Generating the image with source rpms included ...') - if not misc.SrcpkgsDownload(installed_pkgs, creatoropts["repomd"], creator._instroot, creatoropts["cachedir"]): - msger.warning("Source packages can't be downloaded") - - creator.configure(creatoropts["repomd"]) - creator.copy_kernel() - creator.unmount() - creator.package(creatoropts["outdir"]) - if creatoropts['release'] is not None: - creator.release_output(ksconf, creatoropts['outdir'], creatoropts['release']) - creator.print_outimage_info() - except errors.CreatorError: - raise - finally: - creator.cleanup() - - msger.info("Finished.") - return 0 - - @classmethod - def do_chroot(self, target, cmd=[]):#chroot.py parse opts&args - try: - if len(cmd) != 0: - cmdline = ' '.join(cmd) - else: - cmdline = "/bin/bash" - envcmd = fs_related.find_binary_inchroot("env", target) - if envcmd: - cmdline = "%s HOME=/root %s" % (envcmd, cmdline) - chroot.chroot(target, None, cmdline) - finally: - chroot.cleanup_after_chroot("dir", None, None, None) - return 1 diff --git a/scripts/lib/mic/plugins/imager/livecd_plugin.py b/scripts/lib/mic/plugins/imager/livecd_plugin.py deleted file mode 100644 index 82cb1af7dc..0000000000 --- a/scripts/lib/mic/plugins/imager/livecd_plugin.py +++ /dev/null @@ -1,255 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os -import shutil -import tempfile - -from mic import chroot, msger -from mic.utils import misc, fs_related, errors -from mic.conf import configmgr -import mic.imager.livecd as livecd -from mic.plugin import pluginmgr - -from mic.pluginbase import ImagerPlugin -class LiveCDPlugin(ImagerPlugin): - name = 'livecd' - - @classmethod - def do_create(self, subcmd, opts, *args): - """${cmd_name}: create livecd image - - Usage: - ${name} ${cmd_name} <ksfile> [OPTS] - - ${cmd_option_list} - """ - - if len(args) != 1: - raise errors.Usage("Extra arguments given") - - creatoropts = configmgr.create - ksconf = args[0] - - if creatoropts['runtime'] == 'bootstrap': - configmgr._ksconf = ksconf - rt_util.bootstrap_mic() - - if creatoropts['arch'] and creatoropts['arch'].startswith('arm'): - msger.warning('livecd cannot support arm images, Quit') - return - - recording_pkgs = [] - if len(creatoropts['record_pkgs']) > 0: - recording_pkgs = creatoropts['record_pkgs'] - - if creatoropts['release'] is not None: - if 'name' not in recording_pkgs: - recording_pkgs.append('name') - if 'vcs' not in recording_pkgs: - recording_pkgs.append('vcs') - - configmgr._ksconf = ksconf - - # Called After setting the configmgr._ksconf as the creatoropts['name'] is reset there. - if creatoropts['release'] is not None: - creatoropts['outdir'] = "%s/%s/images/%s/" % (creatoropts['outdir'], creatoropts['release'], creatoropts['name']) - - # try to find the pkgmgr - pkgmgr = None - backends = pluginmgr.get_plugins('backend') - if 'auto' == creatoropts['pkgmgr']: - for key in configmgr.prefer_backends: - if key in backends: - pkgmgr = backends[key] - break - else: - for key in backends.keys(): - if key == creatoropts['pkgmgr']: - pkgmgr = backends[key] - break - - if not pkgmgr: - raise errors.CreatorError("Can't find backend: %s, " - "available choices: %s" % - (creatoropts['pkgmgr'], - ','.join(backends.keys()))) - - creator = livecd.LiveCDImageCreator(creatoropts, pkgmgr) - - if len(recording_pkgs) > 0: - creator._recording_pkgs = recording_pkgs - - self.check_image_exists(creator.destdir, - creator.pack_to, - [creator.name + ".iso"], - creatoropts['release']) - - try: - creator.check_depend_tools() - creator.mount(None, creatoropts["cachedir"]) - creator.install() - creator.configure(creatoropts["repomd"]) - creator.copy_kernel() - creator.unmount() - creator.package(creatoropts["outdir"]) - if creatoropts['release'] is not None: - creator.release_output(ksconf, creatoropts['outdir'], creatoropts['release']) - creator.print_outimage_info() - - except errors.CreatorError: - raise - finally: - creator.cleanup() - - msger.info("Finished.") - return 0 - - @classmethod - def do_chroot(cls, target, cmd=[]): - os_image = cls.do_unpack(target) - os_image_dir = os.path.dirname(os_image) - - # unpack image to target dir - imgsize = misc.get_file_size(os_image) * 1024L * 1024L - imgtype = misc.get_image_type(os_image) - if imgtype == "btrfsimg": - fstype = "btrfs" - myDiskMount = fs_related.BtrfsDiskMount - elif imgtype in ("ext3fsimg", "ext4fsimg"): - fstype = imgtype[:4] - myDiskMount = fs_related.ExtDiskMount - else: - raise errors.CreatorError("Unsupported filesystem type: %s" % fstype) - - extmnt = misc.mkdtemp() - extloop = myDiskMount(fs_related.SparseLoopbackDisk(os_image, imgsize), - extmnt, - fstype, - 4096, - "%s label" % fstype) - try: - extloop.mount() - - except errors.MountError: - extloop.cleanup() - shutil.rmtree(extmnt, ignore_errors = True) - shutil.rmtree(os_image_dir, ignore_errors = True) - raise - - try: - if len(cmd) != 0: - cmdline = ' '.join(cmd) - else: - cmdline = "/bin/bash" - envcmd = fs_related.find_binary_inchroot("env", extmnt) - if envcmd: - cmdline = "%s HOME=/root %s" % (envcmd, cmdline) - chroot.chroot(extmnt, None, cmdline) - except: - raise errors.CreatorError("Failed to chroot to %s." %target) - finally: - chroot.cleanup_after_chroot("img", extloop, os_image_dir, extmnt) - - @classmethod - def do_pack(cls, base_on): - import subprocess - - def __mkinitrd(instance): - kernelver = instance._get_kernel_versions().values()[0][0] - args = [ "/usr/libexec/mkliveinitrd", "/boot/initrd-%s.img" % kernelver, "%s" % kernelver ] - try: - subprocess.call(args, preexec_fn = instance._chroot) - except OSError, (err, msg): - raise errors.CreatorError("Failed to execute /usr/libexec/mkliveinitrd: %s" % msg) - - def __run_post_cleanups(instance): - kernelver = instance._get_kernel_versions().values()[0][0] - args = ["rm", "-f", "/boot/initrd-%s.img" % kernelver] - - try: - subprocess.call(args, preexec_fn = instance._chroot) - except OSError, (err, msg): - raise errors.CreatorError("Failed to run post cleanups: %s" % msg) - - convertoropts = configmgr.convert - convertoropts['name'] = os.path.splitext(os.path.basename(base_on))[0] - convertor = livecd.LiveCDImageCreator(convertoropts) - imgtype = misc.get_image_type(base_on) - if imgtype == "btrfsimg": - fstype = "btrfs" - elif imgtype in ("ext3fsimg", "ext4fsimg"): - fstype = imgtype[:4] - else: - raise errors.CreatorError("Unsupported filesystem type: %s" % fstype) - convertor._set_fstype(fstype) - try: - convertor.mount(base_on) - __mkinitrd(convertor) - convertor._create_bootconfig() - __run_post_cleanups(convertor) - convertor.launch_shell(convertoropts['shell']) - convertor.unmount() - convertor.package() - convertor.print_outimage_info() - finally: - shutil.rmtree(os.path.dirname(base_on), ignore_errors = True) - - @classmethod - def do_unpack(cls, srcimg): - img = srcimg - imgmnt = misc.mkdtemp() - imgloop = fs_related.DiskMount(fs_related.LoopbackDisk(img, 0), imgmnt) - try: - imgloop.mount() - except errors.MountError: - imgloop.cleanup() - raise - - # legacy LiveOS filesystem layout support, remove for F9 or F10 - if os.path.exists(imgmnt + "/squashfs.img"): - squashimg = imgmnt + "/squashfs.img" - else: - squashimg = imgmnt + "/LiveOS/squashfs.img" - - tmpoutdir = misc.mkdtemp() - # unsquashfs requires outdir mustn't exist - shutil.rmtree(tmpoutdir, ignore_errors = True) - misc.uncompress_squashfs(squashimg, tmpoutdir) - - try: - # legacy LiveOS filesystem layout support, remove for F9 or F10 - if os.path.exists(tmpoutdir + "/os.img"): - os_image = tmpoutdir + "/os.img" - else: - os_image = tmpoutdir + "/LiveOS/ext3fs.img" - - if not os.path.exists(os_image): - raise errors.CreatorError("'%s' is not a valid live CD ISO : neither " - "LiveOS/ext3fs.img nor os.img exist" %img) - - imgname = os.path.basename(srcimg) - imgname = os.path.splitext(imgname)[0] + ".img" - rtimage = os.path.join(tempfile.mkdtemp(dir = "/var/tmp", prefix = "tmp"), imgname) - shutil.copyfile(os_image, rtimage) - - finally: - imgloop.cleanup() - shutil.rmtree(tmpoutdir, ignore_errors = True) - shutil.rmtree(imgmnt, ignore_errors = True) - - return rtimage diff --git a/scripts/lib/mic/plugins/imager/liveusb_plugin.py b/scripts/lib/mic/plugins/imager/liveusb_plugin.py deleted file mode 100644 index 3d53c84410..0000000000 --- a/scripts/lib/mic/plugins/imager/liveusb_plugin.py +++ /dev/null @@ -1,260 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os -import shutil -import tempfile - -from mic import chroot, msger -from mic.utils import misc, fs_related, errors -from mic.utils.partitionedfs import PartitionedMount -from mic.conf import configmgr -from mic.plugin import pluginmgr - -import mic.imager.liveusb as liveusb - -from mic.pluginbase import ImagerPlugin -class LiveUSBPlugin(ImagerPlugin): - name = 'liveusb' - - @classmethod - def do_create(self, subcmd, opts, *args): - """${cmd_name}: create liveusb image - - Usage: - ${name} ${cmd_name} <ksfile> [OPTS] - - ${cmd_option_list} - """ - - if len(args) != 1: - raise errors.Usage("Extra arguments given") - - creatoropts = configmgr.create - ksconf = args[0] - - if creatoropts['runtime'] == "bootstrap": - configmgr._ksconf = ksconf - rt_util.bootstrap_mic() - - if creatoropts['arch'] and creatoropts['arch'].startswith('arm'): - msger.warning('liveusb cannot support arm images, Quit') - return - - recording_pkgs = [] - if len(creatoropts['record_pkgs']) > 0: - recording_pkgs = creatoropts['record_pkgs'] - - if creatoropts['release'] is not None: - if 'name' not in recording_pkgs: - recording_pkgs.append('name') - if 'vcs' not in recording_pkgs: - recording_pkgs.append('vcs') - - configmgr._ksconf = ksconf - - # Called After setting the configmgr._ksconf as the creatoropts['name'] is reset there. - if creatoropts['release'] is not None: - creatoropts['outdir'] = "%s/%s/images/%s/" % (creatoropts['outdir'], creatoropts['release'], creatoropts['name']) - - # try to find the pkgmgr - pkgmgr = None - backends = pluginmgr.get_plugins('backend') - if 'auto' == creatoropts['pkgmgr']: - for key in configmgr.prefer_backends: - if key in backends: - pkgmgr = backends[key] - break - else: - for key in backends.keys(): - if key == creatoropts['pkgmgr']: - pkgmgr = backends[key] - break - - if not pkgmgr: - raise errors.CreatorError("Can't find backend: %s, " - "available choices: %s" % - (creatoropts['pkgmgr'], - ','.join(backends.keys()))) - - creator = liveusb.LiveUSBImageCreator(creatoropts, pkgmgr) - - if len(recording_pkgs) > 0: - creator._recording_pkgs = recording_pkgs - - self.check_image_exists(creator.destdir, - creator.pack_to, - [creator.name + ".usbimg"], - creatoropts['release']) - try: - creator.check_depend_tools() - creator.mount(None, creatoropts["cachedir"]) - creator.install() - creator.configure(creatoropts["repomd"]) - creator.copy_kernel() - creator.unmount() - creator.package(creatoropts["outdir"]) - if creatoropts['release'] is not None: - creator.release_output(ksconf, creatoropts['outdir'], creatoropts['release']) - creator.print_outimage_info() - - except errors.CreatorError: - raise - finally: - creator.cleanup() - - msger.info("Finished.") - return 0 - - @classmethod - def do_chroot(cls, target, cmd=[]): - os_image = cls.do_unpack(target) - os_image_dir = os.path.dirname(os_image) - - # unpack image to target dir - imgsize = misc.get_file_size(os_image) * 1024L * 1024L - imgtype = misc.get_image_type(os_image) - if imgtype == "btrfsimg": - fstype = "btrfs" - myDiskMount = fs_related.BtrfsDiskMount - elif imgtype in ("ext3fsimg", "ext4fsimg"): - fstype = imgtype[:4] - myDiskMount = fs_related.ExtDiskMount - else: - raise errors.CreatorError("Unsupported filesystem type: %s" % fstype) - - extmnt = misc.mkdtemp() - extloop = myDiskMount(fs_related.SparseLoopbackDisk(os_image, imgsize), - extmnt, - fstype, - 4096, - "%s label" % fstype) - - try: - extloop.mount() - - except errors.MountError: - extloop.cleanup() - shutil.rmtree(extmnt, ignore_errors = True) - raise - - try: - if len(cmd) != 0: - cmdline = ' '.join(cmd) - else: - cmdline = "/bin/bash" - envcmd = fs_related.find_binary_inchroot("env", extmnt) - if envcmd: - cmdline = "%s HOME=/root %s" % (envcmd, cmdline) - chroot.chroot(extmnt, None, cmdline) - except: - raise errors.CreatorError("Failed to chroot to %s." %target) - finally: - chroot.cleanup_after_chroot("img", extloop, os_image_dir, extmnt) - - @classmethod - def do_pack(cls, base_on): - import subprocess - - def __mkinitrd(instance): - kernelver = instance._get_kernel_versions().values()[0][0] - args = [ "/usr/libexec/mkliveinitrd", "/boot/initrd-%s.img" % kernelver, "%s" % kernelver ] - try: - subprocess.call(args, preexec_fn = instance._chroot) - - except OSError, (err, msg): - raise errors.CreatorError("Failed to execute /usr/libexec/mkliveinitrd: %s" % msg) - - def __run_post_cleanups(instance): - kernelver = instance._get_kernel_versions().values()[0][0] - args = ["rm", "-f", "/boot/initrd-%s.img" % kernelver] - - try: - subprocess.call(args, preexec_fn = instance._chroot) - except OSError, (err, msg): - raise errors.CreatorError("Failed to run post cleanups: %s" % msg) - - convertoropts = configmgr.convert - convertoropts['name'] = os.path.splitext(os.path.basename(base_on))[0] - convertor = liveusb.LiveUSBImageCreator(convertoropts) - imgtype = misc.get_image_type(base_on) - if imgtype == "btrfsimg": - fstype = "btrfs" - elif imgtype in ("ext3fsimg", "ext4fsimg"): - fstype = imgtype[:4] - else: - raise errors.CreatorError("Unsupported filesystem type: %s" % fstyp) - convertor._set_fstype(fstype) - try: - convertor.mount(base_on) - __mkinitrd(convertor) - convertor._create_bootconfig() - __run_post_cleanups(convertor) - convertor.launch_shell(convertoropts['shell']) - convertor.unmount() - convertor.package() - convertor.print_outimage_info() - finally: - shutil.rmtree(os.path.dirname(base_on), ignore_errors = True) - - @classmethod - def do_unpack(cls, srcimg): - img = srcimg - imgsize = misc.get_file_size(img) * 1024L * 1024L - imgmnt = misc.mkdtemp() - disk = fs_related.SparseLoopbackDisk(img, imgsize) - imgloop = PartitionedMount(imgmnt, skipformat = True) - imgloop.add_disk('/dev/sdb', disk) - imgloop.add_partition(imgsize/1024/1024, "/dev/sdb", "/", "vfat", boot=False) - try: - imgloop.mount() - except errors.MountError: - imgloop.cleanup() - raise - - # legacy LiveOS filesystem layout support, remove for F9 or F10 - if os.path.exists(imgmnt + "/squashfs.img"): - squashimg = imgmnt + "/squashfs.img" - else: - squashimg = imgmnt + "/LiveOS/squashfs.img" - - tmpoutdir = misc.mkdtemp() - # unsquashfs requires outdir mustn't exist - shutil.rmtree(tmpoutdir, ignore_errors = True) - misc.uncompress_squashfs(squashimg, tmpoutdir) - - try: - # legacy LiveOS filesystem layout support, remove for F9 or F10 - if os.path.exists(tmpoutdir + "/os.img"): - os_image = tmpoutdir + "/os.img" - else: - os_image = tmpoutdir + "/LiveOS/ext3fs.img" - - if not os.path.exists(os_image): - raise errors.CreatorError("'%s' is not a valid live CD ISO : neither " - "LiveOS/ext3fs.img nor os.img exist" %img) - imgname = os.path.basename(srcimg) - imgname = os.path.splitext(imgname)[0] + ".img" - rtimage = os.path.join(tempfile.mkdtemp(dir = "/var/tmp", prefix = "tmp"), imgname) - shutil.copyfile(os_image, rtimage) - - finally: - imgloop.cleanup() - shutil.rmtree(tmpoutdir, ignore_errors = True) - shutil.rmtree(imgmnt, ignore_errors = True) - - return rtimage diff --git a/scripts/lib/mic/plugins/imager/loop_plugin.py b/scripts/lib/mic/plugins/imager/loop_plugin.py deleted file mode 100644 index 2a05b3c238..0000000000 --- a/scripts/lib/mic/plugins/imager/loop_plugin.py +++ /dev/null @@ -1,255 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os -import shutil -import tempfile - -from mic import chroot, msger -from mic.utils import misc, fs_related, errors, cmdln -from mic.conf import configmgr -from mic.plugin import pluginmgr -from mic.imager.loop import LoopImageCreator, load_mountpoints - -from mic.pluginbase import ImagerPlugin -class LoopPlugin(ImagerPlugin): - name = 'loop' - - @classmethod - @cmdln.option("--compress-disk-image", dest="compress_image", - type='choice', choices=("gz", "bz2"), default=None, - help="Same with --compress-image") - # alias to compress-image for compatibility - @cmdln.option("--compress-image", dest="compress_image", - type='choice', choices=("gz", "bz2"), default=None, - help="Compress all loop images with 'gz' or 'bz2'") - @cmdln.option("--shrink", action='store_true', default=False, - help="Whether to shrink loop images to minimal size") - def do_create(self, subcmd, opts, *args): - """${cmd_name}: create loop image - - Usage: - ${name} ${cmd_name} <ksfile> [OPTS] - - ${cmd_option_list} - """ - - if len(args) != 1: - raise errors.Usage("Extra arguments given") - - creatoropts = configmgr.create - ksconf = args[0] - - if creatoropts['runtime'] == "bootstrap": - configmgr._ksconf = ksconf - rt_util.bootstrap_mic() - - recording_pkgs = [] - if len(creatoropts['record_pkgs']) > 0: - recording_pkgs = creatoropts['record_pkgs'] - - if creatoropts['release'] is not None: - if 'name' not in recording_pkgs: - recording_pkgs.append('name') - if 'vcs' not in recording_pkgs: - recording_pkgs.append('vcs') - - configmgr._ksconf = ksconf - - # Called After setting the configmgr._ksconf - # as the creatoropts['name'] is reset there. - if creatoropts['release'] is not None: - creatoropts['outdir'] = "%s/%s/images/%s/" % (creatoropts['outdir'], - creatoropts['release'], - creatoropts['name']) - # try to find the pkgmgr - pkgmgr = None - backends = pluginmgr.get_plugins('backend') - if 'auto' == creatoropts['pkgmgr']: - for key in configmgr.prefer_backends: - if key in backends: - pkgmgr = backends[key] - break - else: - for key in backends.keys(): - if key == creatoropts['pkgmgr']: - pkgmgr = backends[key] - break - - if not pkgmgr: - raise errors.CreatorError("Can't find backend: %s, " - "available choices: %s" % - (creatoropts['pkgmgr'], - ','.join(backends.keys()))) - - creator = LoopImageCreator(creatoropts, - pkgmgr, - opts.compress_image, - opts.shrink) - - if len(recording_pkgs) > 0: - creator._recording_pkgs = recording_pkgs - - image_names = [creator.name + ".img"] - image_names.extend(creator.get_image_names()) - self.check_image_exists(creator.destdir, - creator.pack_to, - image_names, - creatoropts['release']) - - try: - creator.check_depend_tools() - creator.mount(None, creatoropts["cachedir"]) - creator.install() - creator.configure(creatoropts["repomd"]) - creator.copy_kernel() - creator.unmount() - creator.package(creatoropts["outdir"]) - - if creatoropts['release'] is not None: - creator.release_output(ksconf, - creatoropts['outdir'], - creatoropts['release']) - creator.print_outimage_info() - - except errors.CreatorError: - raise - finally: - creator.cleanup() - - msger.info("Finished.") - return 0 - - @classmethod - def _do_chroot_tar(cls, target, cmd=[]): - mountfp_xml = os.path.splitext(target)[0] + '.xml' - if not os.path.exists(mountfp_xml): - raise errors.CreatorError("No mount point file found for this tar " - "image, please check %s" % mountfp_xml) - - import tarfile - tar = tarfile.open(target, 'r') - tmpdir = misc.mkdtemp() - tar.extractall(path=tmpdir) - tar.close() - - mntdir = misc.mkdtemp() - - loops = [] - for (mp, label, name, size, fstype) in load_mountpoints(mountfp_xml): - if fstype in ("ext2", "ext3", "ext4"): - myDiskMount = fs_related.ExtDiskMount - elif fstype == "btrfs": - myDiskMount = fs_related.BtrfsDiskMount - elif fstype in ("vfat", "msdos"): - myDiskMount = fs_related.VfatDiskMount - else: - msger.error("Cannot support fstype: %s" % fstype) - - name = os.path.join(tmpdir, name) - size = size * 1024L * 1024L - loop = myDiskMount(fs_related.SparseLoopbackDisk(name, size), - os.path.join(mntdir, mp.lstrip('/')), - fstype, size, label) - - try: - msger.verbose("Mount %s to %s" % (mp, mntdir + mp)) - fs_related.makedirs(os.path.join(mntdir, mp.lstrip('/'))) - loop.mount() - - except: - loop.cleanup() - for lp in reversed(loops): - chroot.cleanup_after_chroot("img", lp, None, mntdir) - - shutil.rmtree(tmpdir, ignore_errors=True) - raise - - loops.append(loop) - - try: - if len(cmd) != 0: - cmdline = "/usr/bin/env HOME=/root " + ' '.join(cmd) - else: - cmdline = "/usr/bin/env HOME=/root /bin/bash" - chroot.chroot(mntdir, None, cmdline) - except: - raise errors.CreatorError("Failed to chroot to %s." % target) - finally: - for loop in reversed(loops): - chroot.cleanup_after_chroot("img", loop, None, mntdir) - - shutil.rmtree(tmpdir, ignore_errors=True) - - @classmethod - def do_chroot(cls, target, cmd=[]): - if target.endswith('.tar'): - import tarfile - if tarfile.is_tarfile(target): - LoopPlugin._do_chroot_tar(target, cmd) - return - else: - raise errors.CreatorError("damaged tarball for loop images") - - img = target - imgsize = misc.get_file_size(img) * 1024L * 1024L - imgtype = misc.get_image_type(img) - if imgtype == "btrfsimg": - fstype = "btrfs" - myDiskMount = fs_related.BtrfsDiskMount - elif imgtype in ("ext3fsimg", "ext4fsimg"): - fstype = imgtype[:4] - myDiskMount = fs_related.ExtDiskMount - else: - raise errors.CreatorError("Unsupported filesystem type: %s" \ - % imgtype) - - extmnt = misc.mkdtemp() - extloop = myDiskMount(fs_related.SparseLoopbackDisk(img, imgsize), - extmnt, - fstype, - 4096, - "%s label" % fstype) - try: - extloop.mount() - - except errors.MountError: - extloop.cleanup() - shutil.rmtree(extmnt, ignore_errors=True) - raise - - try: - if len(cmd) != 0: - cmdline = ' '.join(cmd) - else: - cmdline = "/bin/bash" - envcmd = fs_related.find_binary_inchroot("env", extmnt) - if envcmd: - cmdline = "%s HOME=/root %s" % (envcmd, cmdline) - chroot.chroot(extmnt, None, cmdline) - except: - raise errors.CreatorError("Failed to chroot to %s." % img) - finally: - chroot.cleanup_after_chroot("img", extloop, None, extmnt) - - @classmethod - def do_unpack(cls, srcimg): - image = os.path.join(tempfile.mkdtemp(dir="/var/tmp", prefix="tmp"), - "target.img") - msger.info("Copying file system ...") - shutil.copyfile(srcimg, image) - return image diff --git a/scripts/lib/mic/plugins/imager/raw_plugin.py b/scripts/lib/mic/plugins/imager/raw_plugin.py deleted file mode 100644 index f9625b87e8..0000000000 --- a/scripts/lib/mic/plugins/imager/raw_plugin.py +++ /dev/null @@ -1,275 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os -import shutil -import re -import tempfile - -from mic import chroot, msger -from mic.utils import misc, fs_related, errors, runner, cmdln -from mic.conf import configmgr -from mic.plugin import pluginmgr -from mic.utils.partitionedfs import PartitionedMount - -import mic.imager.raw as raw - -from mic.pluginbase import ImagerPlugin -class RawPlugin(ImagerPlugin): - name = 'raw' - - @classmethod - @cmdln.option("--compress-disk-image", dest="compress_image", type='choice', - choices=("gz", "bz2"), default=None, - help="Same with --compress-image") - @cmdln.option("--compress-image", dest="compress_image", type='choice', - choices=("gz", "bz2"), default = None, - help="Compress all raw images before package") - @cmdln.option("--generate-bmap", action="store_true", default = None, - help="also generate the block map file") - @cmdln.option("--fstab-entry", dest="fstab_entry", type='choice', - choices=("name", "uuid"), default="uuid", - help="Set fstab entry, 'name' means using device names, " - "'uuid' means using filesystem uuid") - def do_create(self, subcmd, opts, *args): - """${cmd_name}: create raw image - - Usage: - ${name} ${cmd_name} <ksfile> [OPTS] - - ${cmd_option_list} - """ - - if len(args) != 1: - raise errors.Usage("Extra arguments given") - - creatoropts = configmgr.create - ksconf = args[0] - - if creatoropts['runtime'] == "bootstrap": - configmgr._ksconf = ksconf - rt_util.bootstrap_mic() - - recording_pkgs = [] - if len(creatoropts['record_pkgs']) > 0: - recording_pkgs = creatoropts['record_pkgs'] - - if creatoropts['release'] is not None: - if 'name' not in recording_pkgs: - recording_pkgs.append('name') - if 'vcs' not in recording_pkgs: - recording_pkgs.append('vcs') - - configmgr._ksconf = ksconf - - # Called After setting the configmgr._ksconf as the creatoropts['name'] is reset there. - if creatoropts['release'] is not None: - creatoropts['outdir'] = "%s/%s/images/%s/" % (creatoropts['outdir'], creatoropts['release'], creatoropts['name']) - - # try to find the pkgmgr - pkgmgr = None - backends = pluginmgr.get_plugins('backend') - if 'auto' == creatoropts['pkgmgr']: - for key in configmgr.prefer_backends: - if key in backends: - pkgmgr = backends[key] - break - else: - for key in backends.keys(): - if key == creatoropts['pkgmgr']: - pkgmgr = backends[key] - break - - if not pkgmgr: - raise errors.CreatorError("Can't find backend: %s, " - "available choices: %s" % - (creatoropts['pkgmgr'], - ','.join(backends.keys()))) - - creator = raw.RawImageCreator(creatoropts, pkgmgr, opts.compress_image, - opts.generate_bmap, opts.fstab_entry) - - if len(recording_pkgs) > 0: - creator._recording_pkgs = recording_pkgs - - images = ["%s-%s.raw" % (creator.name, disk_name) - for disk_name in creator.get_disk_names()] - self.check_image_exists(creator.destdir, - creator.pack_to, - images, - creatoropts['release']) - - try: - creator.check_depend_tools() - creator.mount(None, creatoropts["cachedir"]) - creator.install() - creator.configure(creatoropts["repomd"]) - creator.copy_kernel() - creator.unmount() - creator.generate_bmap() - creator.package(creatoropts["outdir"]) - if creatoropts['release'] is not None: - creator.release_output(ksconf, creatoropts['outdir'], creatoropts['release']) - creator.print_outimage_info() - - except errors.CreatorError: - raise - finally: - creator.cleanup() - - msger.info("Finished.") - return 0 - - @classmethod - def do_chroot(cls, target, cmd=[]): - img = target - imgsize = misc.get_file_size(img) * 1024L * 1024L - partedcmd = fs_related.find_binary_path("parted") - disk = fs_related.SparseLoopbackDisk(img, imgsize) - imgmnt = misc.mkdtemp() - imgloop = PartitionedMount(imgmnt, skipformat = True) - imgloop.add_disk('/dev/sdb', disk) - img_fstype = "ext3" - - msger.info("Partition Table:") - partnum = [] - for line in runner.outs([partedcmd, "-s", img, "print"]).splitlines(): - # no use strip to keep line output here - if "Number" in line: - msger.raw(line) - if line.strip() and line.strip()[0].isdigit(): - partnum.append(line.strip()[0]) - msger.raw(line) - - rootpart = None - if len(partnum) > 1: - rootpart = msger.choice("please choose root partition", partnum) - - # Check the partitions from raw disk. - # if choose root part, the mark it as mounted - if rootpart: - root_mounted = True - else: - root_mounted = False - partition_mounts = 0 - for line in runner.outs([partedcmd,"-s",img,"unit","B","print"]).splitlines(): - line = line.strip() - - # Lines that start with number are the partitions, - # because parted can be translated we can't refer to any text lines. - if not line or not line[0].isdigit(): - continue - - # Some vars have extra , as list seperator. - line = line.replace(",","") - - # Example of parted output lines that are handled: - # Number Start End Size Type File system Flags - # 1 512B 3400000511B 3400000000B primary - # 2 3400531968B 3656384511B 255852544B primary linux-swap(v1) - # 3 3656384512B 3720347647B 63963136B primary fat16 boot, lba - - partition_info = re.split("\s+",line) - - size = partition_info[3].split("B")[0] - - if len(partition_info) < 6 or partition_info[5] in ["boot"]: - # No filesystem can be found from partition line. Assuming - # btrfs, because that is the only MeeGo fs that parted does - # not recognize properly. - # TODO: Can we make better assumption? - fstype = "btrfs" - elif partition_info[5] in ["ext2","ext3","ext4","btrfs"]: - fstype = partition_info[5] - elif partition_info[5] in ["fat16","fat32"]: - fstype = "vfat" - elif "swap" in partition_info[5]: - fstype = "swap" - else: - raise errors.CreatorError("Could not recognize partition fs type '%s'." % partition_info[5]) - - if rootpart and rootpart == line[0]: - mountpoint = '/' - elif not root_mounted and fstype in ["ext2","ext3","ext4","btrfs"]: - # TODO: Check that this is actually the valid root partition from /etc/fstab - mountpoint = "/" - root_mounted = True - elif fstype == "swap": - mountpoint = "swap" - else: - # TODO: Assing better mount points for the rest of the partitions. - partition_mounts += 1 - mountpoint = "/media/partition_%d" % partition_mounts - - if "boot" in partition_info: - boot = True - else: - boot = False - - msger.verbose("Size: %s Bytes, fstype: %s, mountpoint: %s, boot: %s" % (size, fstype, mountpoint, boot)) - # TODO: add_partition should take bytes as size parameter. - imgloop.add_partition((int)(size)/1024/1024, "/dev/sdb", mountpoint, fstype = fstype, boot = boot) - - try: - imgloop.mount() - - except errors.MountError: - imgloop.cleanup() - raise - - try: - if len(cmd) != 0: - cmdline = ' '.join(cmd) - else: - cmdline = "/bin/bash" - envcmd = fs_related.find_binary_inchroot("env", imgmnt) - if envcmd: - cmdline = "%s HOME=/root %s" % (envcmd, cmdline) - chroot.chroot(imgmnt, None, cmdline) - except: - raise errors.CreatorError("Failed to chroot to %s." %img) - finally: - chroot.cleanup_after_chroot("img", imgloop, None, imgmnt) - - @classmethod - def do_unpack(cls, srcimg): - srcimgsize = (misc.get_file_size(srcimg)) * 1024L * 1024L - srcmnt = misc.mkdtemp("srcmnt") - disk = fs_related.SparseLoopbackDisk(srcimg, srcimgsize) - srcloop = PartitionedMount(srcmnt, skipformat = True) - - srcloop.add_disk('/dev/sdb', disk) - srcloop.add_partition(srcimgsize/1024/1024, "/dev/sdb", "/", "ext3", boot=False) - try: - srcloop.mount() - - except errors.MountError: - srcloop.cleanup() - raise - - image = os.path.join(tempfile.mkdtemp(dir = "/var/tmp", prefix = "tmp"), "target.img") - args = ['dd', "if=%s" % srcloop.partitions[0]['device'], "of=%s" % image] - - msger.info("`dd` image ...") - rc = runner.show(args) - srcloop.cleanup() - shutil.rmtree(os.path.dirname(srcmnt), ignore_errors = True) - - if rc != 0: - raise errors.CreatorError("Failed to dd") - else: - return image diff --git a/scripts/lib/mic/plugins/source/bootimg-efi.py b/scripts/lib/mic/plugins/source/bootimg-efi.py deleted file mode 100644 index 0dd9152b59..0000000000 --- a/scripts/lib/mic/plugins/source/bootimg-efi.py +++ /dev/null @@ -1,169 +0,0 @@ -# ex:ts=4:sw=4:sts=4:et -# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- -# -# Copyright (c) 2014, Intel Corporation. -# All rights reserved. -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License version 2 as -# published by the Free Software Foundation. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., -# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. -# -# DESCRIPTION -# This implements the 'bootimg-efi' source plugin class for 'wic' -# -# AUTHORS -# Tom Zanussi <tom.zanussi (at] linux.intel.com> -# - -import os -import shutil -import re -import tempfile - -from mic import kickstart, chroot, msger -from mic.utils import misc, fs_related, errors, runner, cmdln -from mic.conf import configmgr -from mic.plugin import pluginmgr -from mic.utils.partitionedfs import PartitionedMount -import mic.imager.direct as direct -from mic.pluginbase import SourcePlugin -from mic.utils.oe.misc import * -from mic.imager.direct import DirectImageCreator - -class BootimgEFIPlugin(SourcePlugin): - name = 'bootimg-efi' - - @classmethod - def do_configure_partition(self, part, cr, cr_workdir, oe_builddir, - bootimg_dir, kernel_dir, native_sysroot): - """ - Called before do_prepare_partition(), creates grubefi config - """ - hdddir = "%s/hdd/boot" % cr_workdir - rm_cmd = "rm -rf %s" % cr_workdir - exec_cmd(rm_cmd) - - install_cmd = "install -d %s/EFI/BOOT" % hdddir - tmp = exec_cmd(install_cmd) - - splash = os.path.join(cr_workdir, "/EFI/boot/splash.jpg") - if os.path.exists(splash): - splashline = "menu background splash.jpg" - else: - splashline = "" - - (rootdev, root_part_uuid) = cr._get_boot_config() - options = cr.ks.handler.bootloader.appendLine - - grubefi_conf = "" - grubefi_conf += "serial --unit=0 --speed=115200 --word=8 --parity=no --stop=1\n" - grubefi_conf += "default=boot\n" - timeout = kickstart.get_timeout(cr.ks) - if not timeout: - timeout = 0 - grubefi_conf += "timeout=%s\n" % timeout - grubefi_conf += "menuentry 'boot'{\n" - - kernel = "/vmlinuz" - - if cr._ptable_format == 'msdos': - rootstr = rootdev - else: - if not root_part_uuid: - raise MountError("Cannot find the root GPT partition UUID") - rootstr = "PARTUUID=%s" % root_part_uuid - - grubefi_conf += "linux %s root=%s rootwait %s\n" \ - % (kernel, rootstr, options) - grubefi_conf += "}\n" - if splashline: - syslinux_conf += "%s\n" % splashline - - msger.debug("Writing grubefi config %s/hdd/boot/EFI/BOOT/grub.cfg" \ - % cr_workdir) - cfg = open("%s/hdd/boot/EFI/BOOT/grub.cfg" % cr_workdir, "w") - cfg.write(grubefi_conf) - cfg.close() - - @classmethod - def do_prepare_partition(self, part, cr, cr_workdir, oe_builddir, bootimg_dir, - kernel_dir, rootfs_dir, native_sysroot): - """ - Called to do the actual content population for a partition i.e. it - 'prepares' the partition to be incorporated into the image. - In this case, prepare content for an EFI (grub) boot partition. - """ - if not bootimg_dir: - bootimg_dir = get_bitbake_var("HDDDIR") - if not bootimg_dir: - msger.error("Couldn't find HDDDIR, exiting\n") - # just so the result notes display it - cr.set_bootimg_dir(bootimg_dir) - - staging_kernel_dir = kernel_dir - staging_data_dir = bootimg_dir - - hdddir = "%s/hdd/boot" % cr_workdir - - install_cmd = "install -m 0644 %s/bzImage %s/bzImage" % \ - (staging_kernel_dir, hdddir) - tmp = exec_cmd(install_cmd) - - shutil.copyfile("%s/hdd/boot/EFI/BOOT/grub.cfg" % cr_workdir, - "%s/grub.cfg" % cr_workdir) - - cp_cmd = "cp %s/EFI/BOOT/* %s/EFI/BOOT" % (staging_data_dir, hdddir) - exec_cmd(cp_cmd, True) - - shutil.move("%s/grub.cfg" % cr_workdir, - "%s/hdd/boot/EFI/BOOT/grub.cfg" % cr_workdir) - - du_cmd = "du -bks %s" % hdddir - rc, out = exec_cmd(du_cmd) - blocks = int(out.split()[0]) - - extra_blocks = part.get_extra_block_count(blocks) - - if extra_blocks < BOOTDD_EXTRA_SPACE: - extra_blocks = BOOTDD_EXTRA_SPACE - - blocks += extra_blocks - - msger.debug("Added %d extra blocks to %s to get to %d total blocks" % \ - (extra_blocks, part.mountpoint, blocks)) - - # Ensure total sectors is an integral number of sectors per - # track or mcopy will complain. Sectors are 512 bytes, and we - # generate images with 32 sectors per track. This calculation is - # done in blocks, thus the mod by 16 instead of 32. - blocks += (16 - (blocks % 16)) - - # dosfs image, created by mkdosfs - bootimg = "%s/boot.img" % cr_workdir - - dosfs_cmd = "mkdosfs -n efi -C %s %d" % (bootimg, blocks) - exec_native_cmd(dosfs_cmd, native_sysroot) - - mcopy_cmd = "mcopy -i %s -s %s/* ::/" % (bootimg, hdddir) - exec_native_cmd(mcopy_cmd, native_sysroot) - - chmod_cmd = "chmod 644 %s" % bootimg - exec_cmd(chmod_cmd) - - du_cmd = "du -Lbms %s" % bootimg - rc, out = exec_cmd(du_cmd) - bootimg_size = out.split()[0] - - part.set_size(bootimg_size) - part.set_source_file(bootimg) - - diff --git a/scripts/lib/mic/plugins/source/bootimg-pcbios.py b/scripts/lib/mic/plugins/source/bootimg-pcbios.py deleted file mode 100644 index 1211e5c93b..0000000000 --- a/scripts/lib/mic/plugins/source/bootimg-pcbios.py +++ /dev/null @@ -1,195 +0,0 @@ -# ex:ts=4:sw=4:sts=4:et -# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- -# -# Copyright (c) 2014, Intel Corporation. -# All rights reserved. -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License version 2 as -# published by the Free Software Foundation. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., -# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. -# -# DESCRIPTION -# This implements the 'bootimg-pcbios' source plugin class for 'wic' -# -# AUTHORS -# Tom Zanussi <tom.zanussi (at] linux.intel.com> -# - -import os -import shutil -import re -import tempfile - -from mic import kickstart, chroot, msger -from mic.utils import misc, fs_related, errors, runner, cmdln -from mic.conf import configmgr -from mic.plugin import pluginmgr -from mic.utils.partitionedfs import PartitionedMount -import mic.imager.direct as direct -from mic.pluginbase import SourcePlugin -from mic.utils.oe.misc import * -from mic.imager.direct import DirectImageCreator - -class BootimgPcbiosPlugin(SourcePlugin): - name = 'bootimg-pcbios' - - @classmethod - def do_install_disk(self, disk, disk_name, cr, workdir, oe_builddir, - bootimg_dir, kernel_dir, native_sysroot): - """ - Called after all partitions have been prepared and assembled into a - disk image. In this case, we install the MBR. - """ - mbrfile = "%s/syslinux/" % bootimg_dir - if cr._ptable_format == 'gpt': - mbrfile += "gptmbr.bin" - else: - mbrfile += "mbr.bin" - - if not os.path.exists(mbrfile): - msger.error("Couldn't find %s. If using the -e option, do you have the right MACHINE set in local.conf? If not, is the bootimg_dir path correct?" % mbrfile) - - full_path = cr._full_path(workdir, disk_name, "direct") - msger.debug("Installing MBR on disk %s as %s with size %s bytes" \ - % (disk_name, full_path, disk['min_size'])) - - rc = runner.show(['dd', 'if=%s' % mbrfile, - 'of=%s' % full_path, 'conv=notrunc']) - if rc != 0: - raise MountError("Unable to set MBR to %s" % full_path) - - @classmethod - def do_configure_partition(self, part, cr, cr_workdir, oe_builddir, - bootimg_dir, kernel_dir, native_sysroot): - """ - Called before do_prepare_partition(), creates syslinux config - """ - hdddir = "%s/hdd/boot" % cr_workdir - rm_cmd = "rm -rf " + cr_workdir - exec_cmd(rm_cmd) - - install_cmd = "install -d %s" % hdddir - tmp = exec_cmd(install_cmd) - - splash = os.path.join(cr_workdir, "/hdd/boot/splash.jpg") - if os.path.exists(splash): - splashline = "menu background splash.jpg" - else: - splashline = "" - - (rootdev, root_part_uuid) = cr._get_boot_config() - options = cr.ks.handler.bootloader.appendLine - - syslinux_conf = "" - syslinux_conf += "PROMPT 0\n" - timeout = kickstart.get_timeout(cr.ks) - if not timeout: - timeout = 0 - syslinux_conf += "TIMEOUT " + str(timeout) + "\n" - syslinux_conf += "\n" - syslinux_conf += "ALLOWOPTIONS 1\n" - syslinux_conf += "SERIAL 0 115200\n" - syslinux_conf += "\n" - if splashline: - syslinux_conf += "%s\n" % splashline - syslinux_conf += "DEFAULT boot\n" - syslinux_conf += "LABEL boot\n" - - kernel = "/vmlinuz" - syslinux_conf += "KERNEL " + kernel + "\n" - - if cr._ptable_format == 'msdos': - rootstr = rootdev - else: - if not root_part_uuid: - raise MountError("Cannot find the root GPT partition UUID") - rootstr = "PARTUUID=%s" % root_part_uuid - - syslinux_conf += "APPEND label=boot root=%s %s\n" % (rootstr, options) - - msger.debug("Writing syslinux config %s/hdd/boot/syslinux.cfg" \ - % cr_workdir) - cfg = open("%s/hdd/boot/syslinux.cfg" % cr_workdir, "w") - cfg.write(syslinux_conf) - cfg.close() - - @classmethod - def do_prepare_partition(self, part, cr, cr_workdir, oe_builddir, bootimg_dir, - kernel_dir, rootfs_dir, native_sysroot): - """ - Called to do the actual content population for a partition i.e. it - 'prepares' the partition to be incorporated into the image. - In this case, prepare content for legacy bios boot partition. - """ - if not bootimg_dir: - bootimg_dir = get_bitbake_var("STAGING_DATADIR") - if not bootimg_dir: - msger.error("Couldn't find STAGING_DATADIR, exiting\n") - # just so the result notes display it - cr.set_bootimg_dir(bootimg_dir) - - staging_kernel_dir = kernel_dir - staging_data_dir = bootimg_dir - - hdddir = "%s/hdd/boot" % cr_workdir - - install_cmd = "install -m 0644 %s/bzImage %s/vmlinuz" \ - % (staging_kernel_dir, hdddir) - tmp = exec_cmd(install_cmd) - - install_cmd = "install -m 444 %s/syslinux/ldlinux.sys %s/ldlinux.sys" \ - % (staging_data_dir, hdddir) - tmp = exec_cmd(install_cmd) - - du_cmd = "du -bks %s" % hdddir - rc, out = exec_cmd(du_cmd) - blocks = int(out.split()[0]) - - extra_blocks = part.get_extra_block_count(blocks) - - if extra_blocks < BOOTDD_EXTRA_SPACE: - extra_blocks = BOOTDD_EXTRA_SPACE - - blocks += extra_blocks - - msger.debug("Added %d extra blocks to %s to get to %d total blocks" % \ - (extra_blocks, part.mountpoint, blocks)) - - # Ensure total sectors is an integral number of sectors per - # track or mcopy will complain. Sectors are 512 bytes, and we - # generate images with 32 sectors per track. This calculation is - # done in blocks, thus the mod by 16 instead of 32. - blocks += (16 - (blocks % 16)) - - # dosfs image, created by mkdosfs - bootimg = "%s/boot.img" % cr_workdir - - dosfs_cmd = "mkdosfs -n boot -S 512 -C %s %d" % (bootimg, blocks) - exec_native_cmd(dosfs_cmd, native_sysroot) - - mcopy_cmd = "mcopy -i %s -s %s/* ::/" % (bootimg, hdddir) - exec_native_cmd(mcopy_cmd, native_sysroot) - - syslinux_cmd = "syslinux %s" % bootimg - exec_native_cmd(syslinux_cmd, native_sysroot) - - chmod_cmd = "chmod 644 %s" % bootimg - exec_cmd(chmod_cmd) - - du_cmd = "du -Lbms %s" % bootimg - rc, out = exec_cmd(du_cmd) - bootimg_size = out.split()[0] - - part.set_size(bootimg_size) - part.set_source_file(bootimg) - - diff --git a/scripts/lib/mic/plugins/source/rootfs.py b/scripts/lib/mic/plugins/source/rootfs.py deleted file mode 100644 index a4d4547318..0000000000 --- a/scripts/lib/mic/plugins/source/rootfs.py +++ /dev/null @@ -1,92 +0,0 @@ -# ex:ts=4:sw=4:sts=4:et -# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- -# -# Copyright (c) 2014, Intel Corporation. -# All rights reserved. -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License version 2 as -# published by the Free Software Foundation. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., -# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. -# -# DESCRIPTION -# This implements the 'rootfs' source plugin class for 'wic' -# -# AUTHORS -# Tom Zanussi <tom.zanussi (at] linux.intel.com> -# Joao Henrique Ferreira de Freitas <joaohf (at] gmail.com> -# - -import os -import shutil -import re -import tempfile - -from mic import kickstart, chroot, msger -from mic.utils import misc, fs_related, errors, runner, cmdln -from mic.conf import configmgr -from mic.plugin import pluginmgr -from mic.utils.partitionedfs import PartitionedMount -import mic.imager.direct as direct -from mic.pluginbase import SourcePlugin -from mic.utils.oe.misc import * -from mic.imager.direct import DirectImageCreator - -class RootfsPlugin(SourcePlugin): - name = 'rootfs' - - @staticmethod - def __get_rootfs_dir(rootfs_dir): - if os.path.isdir(rootfs_dir): - return rootfs_dir - - bitbake_env_lines = find_bitbake_env_lines(rootfs_dir) - if not bitbake_env_lines: - msg = "Couldn't get bitbake environment, exiting." - msger.error(msg) - - image_rootfs_dir = find_artifact(bitbake_env_lines, "IMAGE_ROOTFS") - if not os.path.isdir(image_rootfs_dir): - msg = "No valid artifact IMAGE_ROOTFS from image named" - msg += " %s has been found at %s, exiting.\n" % \ - (rootfs_dir, image_rootfs_dir) - msger.error(msg) - - return image_rootfs_dir - - @classmethod - def do_prepare_partition(self, part, cr, cr_workdir, oe_builddir, bootimg_dir, - kernel_dir, krootfs_dir, native_sysroot): - """ - Called to do the actual content population for a partition i.e. it - 'prepares' the partition to be incorporated into the image. - In this case, prepare content for legacy bios boot partition. - """ - if part.rootfs is None: - if not 'ROOTFS_DIR' in krootfs_dir: - msg = "Couldn't find --rootfs-dir, exiting" - msger.error(msg) - rootfs_dir = krootfs_dir['ROOTFS_DIR'] - else: - if part.rootfs in krootfs_dir: - rootfs_dir = krootfs_dir[part.rootfs] - elif part.rootfs: - rootfs_dir = part.rootfs - else: - msg = "Couldn't find --rootfs-dir=%s connection" - msg += " or it is not a valid path, exiting" - msger.error(msg % part.rootfs) - - real_rootfs_dir = self.__get_rootfs_dir(rootfs_dir) - - part.set_rootfs(real_rootfs_dir) - part.prepare_rootfs(cr_workdir, oe_builddir, real_rootfs_dir, native_sysroot) - diff --git a/scripts/lib/mic/rt_util.py b/scripts/lib/mic/rt_util.py deleted file mode 100644 index 2a31f4a218..0000000000 --- a/scripts/lib/mic/rt_util.py +++ /dev/null @@ -1,223 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2009, 2010, 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -from __future__ import with_statement -import os -import sys -import glob -import re -import shutil -import subprocess - -from mic import bootstrap, msger -from mic.conf import configmgr -from mic.utils import errors, proxy -from mic.utils.fs_related import find_binary_path, makedirs -from mic.chroot import setup_chrootenv, cleanup_chrootenv - -expath = lambda p: os.path.abspath(os.path.expanduser(p)) - -def bootstrap_mic(argv=None): - - - def mychroot(): - os.chroot(rootdir) - os.chdir(cwd) - - # by default, sys.argv is used to run mic in bootstrap - if not argv: - argv = sys.argv - if argv[0] not in ('/usr/bin/mic', 'mic'): - argv[0] = '/usr/bin/mic' - - cropts = configmgr.create - bsopts = configmgr.bootstrap - distro = bsopts['distro_name'].lower() - - rootdir = bsopts['rootdir'] - pkglist = bsopts['packages'] - cwd = os.getcwd() - - # create bootstrap and run mic in bootstrap - bsenv = bootstrap.Bootstrap(rootdir, distro, cropts['arch']) - bsenv.logfile = cropts['logfile'] - # rootdir is regenerated as a temp dir - rootdir = bsenv.rootdir - - if 'optional' in bsopts: - optlist = bsopts['optional'] - else: - optlist = [] - - try: - msger.info("Creating %s bootstrap ..." % distro) - bsenv.create(cropts['repomd'], pkglist, optlist) - - # bootstrap is relocated under "bootstrap" - if os.path.exists(os.path.join(rootdir, "bootstrap")): - rootdir = os.path.join(rootdir, "bootstrap") - - bsenv.dirsetup(rootdir) - sync_mic(rootdir) - - #FIXME: sync the ks file to bootstrap - if "/" == os.path.dirname(os.path.abspath(configmgr._ksconf)): - safecopy(configmgr._ksconf, rootdir) - - msger.info("Start mic in bootstrap: %s\n" % rootdir) - bindmounts = get_bindmounts(cropts) - ret = bsenv.run(argv, cwd, rootdir, bindmounts) - - except errors.BootstrapError, err: - msger.warning('\n%s' % err) - if msger.ask("Switch to native mode and continue?"): - return - raise - except RuntimeError, err: - #change exception type but keep the trace back - value, tb = sys.exc_info()[1:] - raise errors.BootstrapError, value, tb - else: - sys.exit(ret) - finally: - bsenv.cleanup() - -def get_bindmounts(cropts): - binddirs = [ - os.getcwd(), - cropts['tmpdir'], - cropts['cachedir'], - cropts['outdir'], - cropts['local_pkgs_path'], - ] - bindfiles = [ - cropts['logfile'], - configmgr._ksconf, - ] - - for lrepo in cropts['localrepos']: - binddirs.append(lrepo) - - bindlist = map(expath, filter(None, binddirs)) - bindlist += map(os.path.dirname, map(expath, filter(None, bindfiles))) - bindlist = sorted(set(bindlist)) - bindmounts = ';'.join(bindlist) - return bindmounts - - -def get_mic_binpath(): - fp = None - try: - import pkg_resources # depends on 'setuptools' - except ImportError: - pass - else: - dist = pkg_resources.get_distribution('mic') - # the real script is under EGG_INFO/scripts - if dist.has_metadata('scripts/mic'): - fp = os.path.join(dist.egg_info, "scripts/mic") - - if fp: - return fp - - # not found script if 'flat' egg installed - try: - return find_binary_path('mic') - except errors.CreatorError: - raise errors.BootstrapError("Can't find mic binary in host OS") - - -def get_mic_modpath(): - try: - import mic - except ImportError: - raise errors.BootstrapError("Can't find mic module in host OS") - path = os.path.abspath(mic.__file__) - return os.path.dirname(path) - -def get_mic_libpath(): - # TBD: so far mic lib path is hard coded - return "/usr/lib/mic" - -# the hard code path is prepared for bootstrap -def sync_mic(bootstrap, binpth = '/usr/bin/mic', - libpth='/usr/lib', - pylib = '/usr/lib/python2.7/site-packages', - conf = '/etc/mic/mic.conf'): - _path = lambda p: os.path.join(bootstrap, p.lstrip('/')) - - micpaths = { - 'binpth': get_mic_binpath(), - 'libpth': get_mic_libpath(), - 'pylib': get_mic_modpath(), - 'conf': '/etc/mic/mic.conf', - } - - if not os.path.exists(_path(pylib)): - pyptn = '/usr/lib/python?.?/site-packages' - pylibs = glob.glob(_path(pyptn)) - if pylibs: - pylib = pylibs[0].replace(bootstrap, '') - else: - raise errors.BootstrapError("Can't find python site dir in: %s" % - bootstrap) - - for key, value in micpaths.items(): - try: - safecopy(value, _path(eval(key)), False, ["*.pyc", "*.pyo"]) - except (OSError, IOError), err: - raise errors.BootstrapError(err) - - # auto select backend - conf_str = file(_path(conf)).read() - conf_str = re.sub("pkgmgr\s*=\s*.*", "pkgmgr=auto", conf_str) - with open(_path(conf), 'w') as wf: - wf.write(conf_str) - - # chmod +x /usr/bin/mic - os.chmod(_path(binpth), 0777) - - # correct python interpreter - mic_cont = file(_path(binpth)).read() - mic_cont = "#!/usr/bin/python\n" + mic_cont - with open(_path(binpth), 'w') as wf: - wf.write(mic_cont) - - -def safecopy(src, dst, symlinks=False, ignore_ptns=()): - if os.path.isdir(src): - if os.path.isdir(dst): - dst = os.path.join(dst, os.path.basename(src)) - if os.path.exists(dst): - shutil.rmtree(dst, ignore_errors=True) - - src = src.rstrip('/') - # check common prefix to ignore copying itself - if dst.startswith(src + '/'): - ignore_ptns = list(ignore_ptns) + [ os.path.basename(src) ] - - ignores = shutil.ignore_patterns(*ignore_ptns) - try: - shutil.copytree(src, dst, symlinks, ignores) - except (OSError, IOError): - shutil.rmtree(dst, ignore_errors=True) - raise - else: - if not os.path.isdir(dst): - makedirs(os.path.dirname(dst)) - - shutil.copy2(src, dst) diff --git a/scripts/lib/mic/test b/scripts/lib/mic/test deleted file mode 100644 index 9daeafb986..0000000000 --- a/scripts/lib/mic/test +++ /dev/null @@ -1 +0,0 @@ -test diff --git a/scripts/lib/mic/utils/BmapCreate.py b/scripts/lib/mic/utils/BmapCreate.py deleted file mode 100644 index 65b19a5f46..0000000000 --- a/scripts/lib/mic/utils/BmapCreate.py +++ /dev/null @@ -1,298 +0,0 @@ -""" This module implements the block map (bmap) creation functionality and -provides the corresponding API in form of the 'BmapCreate' class. - -The idea is that while images files may generally be very large (e.g., 4GiB), -they may nevertheless contain only little real data, e.g., 512MiB. This data -are files, directories, file-system meta-data, partition table, etc. When -copying the image to the target device, you do not have to copy all the 4GiB of -data, you can copy only 512MiB of it, which is 4 times less, so copying should -presumably be 4 times faster. - -The block map file is an XML file which contains a list of blocks which have to -be copied to the target device. The other blocks are not used and there is no -need to copy them. The XML file also contains some additional information like -block size, image size, count of mapped blocks, etc. There are also many -commentaries, so it is human-readable. - -The image has to be a sparse file. Generally, this means that when you generate -this image file, you should start with a huge sparse file which contains a -single hole spanning the entire file. Then you should partition it, write all -the data (probably by means of loop-back mounting the image or parts of it), -etc. The end result should be a sparse file where mapped areas represent useful -parts of the image and holes represent useless parts of the image, which do not -have to be copied when copying the image to the target device. - -This module uses the FIBMAP ioctl to detect holes. """ - -# Disable the following pylint recommendations: -# * Too many instance attributes - R0902 -# * Too few public methods - R0903 -# pylint: disable=R0902,R0903 - -import hashlib -from mic.utils.misc import human_size -from mic.utils import Fiemap - -# The bmap format version we generate -SUPPORTED_BMAP_VERSION = "1.3" - -_BMAP_START_TEMPLATE = \ -"""<?xml version="1.0" ?> -<!-- This file contains the block map for an image file, which is basically - a list of useful (mapped) block numbers in the image file. In other words, - it lists only those blocks which contain data (boot sector, partition - table, file-system metadata, files, directories, extents, etc). These - blocks have to be copied to the target device. The other blocks do not - contain any useful data and do not have to be copied to the target - device. - - The block map an optimization which allows to copy or flash the image to - the image quicker than copying of flashing the entire image. This is - because with bmap less data is copied: <MappedBlocksCount> blocks instead - of <BlocksCount> blocks. - - Besides the machine-readable data, this file contains useful commentaries - which contain human-readable information like image size, percentage of - mapped data, etc. - - The 'version' attribute is the block map file format version in the - 'major.minor' format. The version major number is increased whenever an - incompatible block map format change is made. The minor number changes - in case of minor backward-compatible changes. --> - -<bmap version="%s"> - <!-- Image size in bytes: %s --> - <ImageSize> %u </ImageSize> - - <!-- Size of a block in bytes --> - <BlockSize> %u </BlockSize> - - <!-- Count of blocks in the image file --> - <BlocksCount> %u </BlocksCount> - -""" - -class Error(Exception): - """ A class for exceptions generated by this module. We currently support - only one type of exceptions, and we basically throw human-readable problem - description in case of errors. """ - pass - -class BmapCreate: - """ This class implements the bmap creation functionality. To generate a - bmap for an image (which is supposedly a sparse file), you should first - create an instance of 'BmapCreate' and provide: - - * full path or a file-like object of the image to create bmap for - * full path or a file object to use for writing the results to - - Then you should invoke the 'generate()' method of this class. It will use - the FIEMAP ioctl to generate the bmap. """ - - def _open_image_file(self): - """ Open the image file. """ - - try: - self._f_image = open(self._image_path, 'rb') - except IOError as err: - raise Error("cannot open image file '%s': %s" \ - % (self._image_path, err)) - - self._f_image_needs_close = True - - def _open_bmap_file(self): - """ Open the bmap file. """ - - try: - self._f_bmap = open(self._bmap_path, 'w+') - except IOError as err: - raise Error("cannot open bmap file '%s': %s" \ - % (self._bmap_path, err)) - - self._f_bmap_needs_close = True - - def __init__(self, image, bmap): - """ Initialize a class instance: - * image - full path or a file-like object of the image to create bmap - for - * bmap - full path or a file object to use for writing the resulting - bmap to """ - - self.image_size = None - self.image_size_human = None - self.block_size = None - self.blocks_cnt = None - self.mapped_cnt = None - self.mapped_size = None - self.mapped_size_human = None - self.mapped_percent = None - - self._mapped_count_pos1 = None - self._mapped_count_pos2 = None - self._sha1_pos = None - - self._f_image_needs_close = False - self._f_bmap_needs_close = False - - if hasattr(image, "read"): - self._f_image = image - self._image_path = image.name - else: - self._image_path = image - self._open_image_file() - - if hasattr(bmap, "read"): - self._f_bmap = bmap - self._bmap_path = bmap.name - else: - self._bmap_path = bmap - self._open_bmap_file() - - self.fiemap = Fiemap.Fiemap(self._f_image) - - self.image_size = self.fiemap.image_size - self.image_size_human = human_size(self.image_size) - if self.image_size == 0: - raise Error("cannot generate bmap for zero-sized image file '%s'" \ - % self._image_path) - - self.block_size = self.fiemap.block_size - self.blocks_cnt = self.fiemap.blocks_cnt - - def _bmap_file_start(self): - """ A helper function which generates the starting contents of the - block map file: the header comment, image size, block size, etc. """ - - # We do not know the amount of mapped blocks at the moment, so just put - # whitespaces instead of real numbers. Assume the longest possible - # numbers. - mapped_count = ' ' * len(str(self.image_size)) - mapped_size_human = ' ' * len(self.image_size_human) - - xml = _BMAP_START_TEMPLATE \ - % (SUPPORTED_BMAP_VERSION, self.image_size_human, - self.image_size, self.block_size, self.blocks_cnt) - xml += " <!-- Count of mapped blocks: " - - self._f_bmap.write(xml) - self._mapped_count_pos1 = self._f_bmap.tell() - - # Just put white-spaces instead of real information about mapped blocks - xml = "%s or %.1f -->\n" % (mapped_size_human, 100.0) - xml += " <MappedBlocksCount> " - - self._f_bmap.write(xml) - self._mapped_count_pos2 = self._f_bmap.tell() - - xml = "%s </MappedBlocksCount>\n\n" % mapped_count - - # pylint: disable=C0301 - xml += " <!-- The checksum of this bmap file. When it is calculated, the value of\n" - xml += " the SHA1 checksum has be zeoro (40 ASCII \"0\" symbols). -->\n" - xml += " <BmapFileSHA1> " - - self._f_bmap.write(xml) - self._sha1_pos = self._f_bmap.tell() - - xml = "0" * 40 + " </BmapFileSHA1>\n\n" - xml += " <!-- The block map which consists of elements which may either be a\n" - xml += " range of blocks or a single block. The 'sha1' attribute (if present)\n" - xml += " is the SHA1 checksum of this blocks range. -->\n" - xml += " <BlockMap>\n" - # pylint: enable=C0301 - - self._f_bmap.write(xml) - - def _bmap_file_end(self): - """ A helper function which generates the final parts of the block map - file: the ending tags and the information about the amount of mapped - blocks. """ - - xml = " </BlockMap>\n" - xml += "</bmap>\n" - - self._f_bmap.write(xml) - - self._f_bmap.seek(self._mapped_count_pos1) - self._f_bmap.write("%s or %.1f%%" % \ - (self.mapped_size_human, self.mapped_percent)) - - self._f_bmap.seek(self._mapped_count_pos2) - self._f_bmap.write("%u" % self.mapped_cnt) - - self._f_bmap.seek(0) - sha1 = hashlib.sha1(self._f_bmap.read()).hexdigest() - self._f_bmap.seek(self._sha1_pos) - self._f_bmap.write("%s" % sha1) - - def _calculate_sha1(self, first, last): - """ A helper function which calculates SHA1 checksum for the range of - blocks of the image file: from block 'first' to block 'last'. """ - - start = first * self.block_size - end = (last + 1) * self.block_size - - self._f_image.seek(start) - hash_obj = hashlib.new("sha1") - - chunk_size = 1024*1024 - to_read = end - start - read = 0 - - while read < to_read: - if read + chunk_size > to_read: - chunk_size = to_read - read - chunk = self._f_image.read(chunk_size) - hash_obj.update(chunk) - read += chunk_size - - return hash_obj.hexdigest() - - def generate(self, include_checksums = True): - """ Generate bmap for the image file. If 'include_checksums' is 'True', - also generate SHA1 checksums for block ranges. """ - - # Save image file position in order to restore it at the end - image_pos = self._f_image.tell() - - self._bmap_file_start() - - # Generate the block map and write it to the XML block map - # file as we go. - self.mapped_cnt = 0 - for first, last in self.fiemap.get_mapped_ranges(0, self.blocks_cnt): - self.mapped_cnt += last - first + 1 - if include_checksums: - sha1 = self._calculate_sha1(first, last) - sha1 = " sha1=\"%s\"" % sha1 - else: - sha1 = "" - - if first != last: - self._f_bmap.write(" <Range%s> %s-%s </Range>\n" \ - % (sha1, first, last)) - else: - self._f_bmap.write(" <Range%s> %s </Range>\n" \ - % (sha1, first)) - - self.mapped_size = self.mapped_cnt * self.block_size - self.mapped_size_human = human_size(self.mapped_size) - self.mapped_percent = (self.mapped_cnt * 100.0) / self.blocks_cnt - - self._bmap_file_end() - - try: - self._f_bmap.flush() - except IOError as err: - raise Error("cannot flush the bmap file '%s': %s" \ - % (self._bmap_path, err)) - - self._f_image.seek(image_pos) - - def __del__(self): - """ The class destructor which closes the opened files. """ - - if self._f_image_needs_close: - self._f_image.close() - if self._f_bmap_needs_close: - self._f_bmap.close() diff --git a/scripts/lib/mic/utils/Fiemap.py b/scripts/lib/mic/utils/Fiemap.py deleted file mode 100644 index f2db6ff0b8..0000000000 --- a/scripts/lib/mic/utils/Fiemap.py +++ /dev/null @@ -1,252 +0,0 @@ -""" This module implements python API for the FIEMAP ioctl. The FIEMAP ioctl -allows to find holes and mapped areas in a file. """ - -# Note, a lot of code in this module is not very readable, because it deals -# with the rather complex FIEMAP ioctl. To understand the code, you need to -# know the FIEMAP interface, which is documented in the -# Documentation/filesystems/fiemap.txt file in the Linux kernel sources. - -# Disable the following pylint recommendations: -# * Too many instance attributes (R0902) -# pylint: disable=R0902 - -import os -import struct -import array -import fcntl -from mic.utils.misc import get_block_size - -# Format string for 'struct fiemap' -_FIEMAP_FORMAT = "=QQLLLL" -# sizeof(struct fiemap) -_FIEMAP_SIZE = struct.calcsize(_FIEMAP_FORMAT) -# Format string for 'struct fiemap_extent' -_FIEMAP_EXTENT_FORMAT = "=QQQQQLLLL" -# sizeof(struct fiemap_extent) -_FIEMAP_EXTENT_SIZE = struct.calcsize(_FIEMAP_EXTENT_FORMAT) -# The FIEMAP ioctl number -_FIEMAP_IOCTL = 0xC020660B - -# Minimum buffer which is required for 'class Fiemap' to operate -MIN_BUFFER_SIZE = _FIEMAP_SIZE + _FIEMAP_EXTENT_SIZE -# The default buffer size for 'class Fiemap' -DEFAULT_BUFFER_SIZE = 256 * 1024 - -class Error(Exception): - """ A class for exceptions generated by this module. We currently support - only one type of exceptions, and we basically throw human-readable problem - description in case of errors. """ - pass - -class Fiemap: - """ This class provides API to the FIEMAP ioctl. Namely, it allows to - iterate over all mapped blocks and over all holes. """ - - def _open_image_file(self): - """ Open the image file. """ - - try: - self._f_image = open(self._image_path, 'rb') - except IOError as err: - raise Error("cannot open image file '%s': %s" \ - % (self._image_path, err)) - - self._f_image_needs_close = True - - def __init__(self, image, buf_size = DEFAULT_BUFFER_SIZE): - """ Initialize a class instance. The 'image' argument is full path to - the file to operate on, or a file object to operate on. - - The 'buf_size' argument is the size of the buffer for 'struct - fiemap_extent' elements which will be used when invoking the FIEMAP - ioctl. The larger is the buffer, the less times the FIEMAP ioctl will - be invoked. """ - - self._f_image_needs_close = False - - if hasattr(image, "fileno"): - self._f_image = image - self._image_path = image.name - else: - self._image_path = image - self._open_image_file() - - # Validate 'buf_size' - if buf_size < MIN_BUFFER_SIZE: - raise Error("too small buffer (%d bytes), minimum is %d bytes" \ - % (buf_size, MIN_BUFFER_SIZE)) - - # How many 'struct fiemap_extent' elements fit the buffer - buf_size -= _FIEMAP_SIZE - self._fiemap_extent_cnt = buf_size / _FIEMAP_EXTENT_SIZE - self._buf_size = self._fiemap_extent_cnt * _FIEMAP_EXTENT_SIZE - self._buf_size += _FIEMAP_SIZE - - # Allocate a mutable buffer for the FIEMAP ioctl - self._buf = array.array('B', [0] * self._buf_size) - - self.image_size = os.fstat(self._f_image.fileno()).st_size - - try: - self.block_size = get_block_size(self._f_image) - except IOError as err: - raise Error("cannot get block size for '%s': %s" \ - % (self._image_path, err)) - - self.blocks_cnt = self.image_size + self.block_size - 1 - self.blocks_cnt /= self.block_size - - # Synchronize the image file to make sure FIEMAP returns correct values - try: - self._f_image.flush() - except IOError as err: - raise Error("cannot flush image file '%s': %s" \ - % (self._image_path, err)) - try: - os.fsync(self._f_image.fileno()), - except OSError as err: - raise Error("cannot synchronize image file '%s': %s " \ - % (self._image_path, err.strerror)) - - # Check if the FIEMAP ioctl is supported - self.block_is_mapped(0) - - def __del__(self): - """ The class destructor which closes the opened files. """ - - if self._f_image_needs_close: - self._f_image.close() - - def _invoke_fiemap(self, block, count): - """ Invoke the FIEMAP ioctl for 'count' blocks of the file starting from - block number 'block'. - - The full result of the operation is stored in 'self._buf' on exit. - Returns the unpacked 'struct fiemap' data structure in form of a python - list (just like 'struct.upack()'). """ - - if block < 0 or block >= self.blocks_cnt: - raise Error("bad block number %d, should be within [0, %d]" \ - % (block, self.blocks_cnt)) - - # Initialize the 'struct fiemap' part of the buffer - struct.pack_into(_FIEMAP_FORMAT, self._buf, 0, block * self.block_size, - count * self.block_size, 0, 0, - self._fiemap_extent_cnt, 0) - - try: - fcntl.ioctl(self._f_image, _FIEMAP_IOCTL, self._buf, 1) - except IOError as err: - error_msg = "the FIEMAP ioctl failed for '%s': %s" \ - % (self._image_path, err) - if err.errno == os.errno.EPERM or err.errno == os.errno.EACCES: - # The FIEMAP ioctl was added in kernel version 2.6.28 in 2008 - error_msg += " (looks like your kernel does not support FIEMAP)" - - raise Error(error_msg) - - return struct.unpack(_FIEMAP_FORMAT, self._buf[:_FIEMAP_SIZE]) - - def block_is_mapped(self, block): - """ This function returns 'True' if block number 'block' of the image - file is mapped and 'False' otherwise. """ - - struct_fiemap = self._invoke_fiemap(block, 1) - - # The 3rd element of 'struct_fiemap' is the 'fm_mapped_extents' field. - # If it contains zero, the block is not mapped, otherwise it is - # mapped. - return bool(struct_fiemap[3]) - - def block_is_unmapped(self, block): - """ This function returns 'True' if block number 'block' of the image - file is not mapped (hole) and 'False' otherwise. """ - - return not self.block_is_mapped(block) - - def _unpack_fiemap_extent(self, index): - """ Unpack a 'struct fiemap_extent' structure object number 'index' - from the internal 'self._buf' buffer. """ - - offset = _FIEMAP_SIZE + _FIEMAP_EXTENT_SIZE * index - return struct.unpack(_FIEMAP_EXTENT_FORMAT, - self._buf[offset : offset + _FIEMAP_EXTENT_SIZE]) - - def _do_get_mapped_ranges(self, start, count): - """ Implements most the functionality for the 'get_mapped_ranges()' - generator: invokes the FIEMAP ioctl, walks through the mapped - extents and yields mapped block ranges. However, the ranges may be - consecutive (e.g., (1, 100), (100, 200)) and 'get_mapped_ranges()' - simply merges them. """ - - block = start - while block < start + count: - struct_fiemap = self._invoke_fiemap(block, count) - - mapped_extents = struct_fiemap[3] - if mapped_extents == 0: - # No more mapped blocks - return - - extent = 0 - while extent < mapped_extents: - fiemap_extent = self._unpack_fiemap_extent(extent) - - # Start of the extent - extent_start = fiemap_extent[0] - # Starting block number of the extent - extent_block = extent_start / self.block_size - # Length of the extent - extent_len = fiemap_extent[2] - # Count of blocks in the extent - extent_count = extent_len / self.block_size - - # Extent length and offset have to be block-aligned - assert extent_start % self.block_size == 0 - assert extent_len % self.block_size == 0 - - if extent_block > start + count - 1: - return - - first = max(extent_block, block) - last = min(extent_block + extent_count, start + count) - 1 - yield (first, last) - - extent += 1 - - block = extent_block + extent_count - - def get_mapped_ranges(self, start, count): - """ A generator which yields ranges of mapped blocks in the file. The - ranges are tuples of 2 elements: [first, last], where 'first' is the - first mapped block and 'last' is the last mapped block. - - The ranges are yielded for the area of the file of size 'count' blocks, - starting from block 'start'. """ - - iterator = self._do_get_mapped_ranges(start, count) - - first_prev, last_prev = iterator.next() - - for first, last in iterator: - if last_prev == first - 1: - last_prev = last - else: - yield (first_prev, last_prev) - first_prev, last_prev = first, last - - yield (first_prev, last_prev) - - def get_unmapped_ranges(self, start, count): - """ Just like 'get_mapped_ranges()', but yields unmapped block ranges - instead (holes). """ - - hole_first = start - for first, last in self._do_get_mapped_ranges(start, count): - if first > hole_first: - yield (hole_first, first - 1) - - hole_first = last + 1 - - if hole_first < start + count: - yield (hole_first, start + count - 1) diff --git a/scripts/lib/mic/utils/__init__.py b/scripts/lib/mic/utils/__init__.py deleted file mode 100644 index e69de29bb2..0000000000 --- a/scripts/lib/mic/utils/__init__.py +++ /dev/null diff --git a/scripts/lib/mic/utils/cmdln.py b/scripts/lib/mic/utils/cmdln.py deleted file mode 100644 index b099473ee4..0000000000 --- a/scripts/lib/mic/utils/cmdln.py +++ /dev/null @@ -1,1586 +0,0 @@ -#!/usr/bin/env python -# Copyright (c) 2002-2007 ActiveState Software Inc. -# License: MIT (see LICENSE.txt for license details) -# Author: Trent Mick -# Home: http://trentm.com/projects/cmdln/ - -"""An improvement on Python's standard cmd.py module. - -As with cmd.py, this module provides "a simple framework for writing -line-oriented command intepreters." This module provides a 'RawCmdln' -class that fixes some design flaws in cmd.Cmd, making it more scalable -and nicer to use for good 'cvs'- or 'svn'-style command line interfaces -or simple shells. And it provides a 'Cmdln' class that add -optparse-based option processing. Basically you use it like this: - - import cmdln - - class MySVN(cmdln.Cmdln): - name = "svn" - - @cmdln.alias('stat', 'st') - @cmdln.option('-v', '--verbose', action='store_true' - help='print verbose information') - def do_status(self, subcmd, opts, *paths): - print "handle 'svn status' command" - - #... - - if __name__ == "__main__": - shell = MySVN() - retval = shell.main() - sys.exit(retval) - -See the README.txt or <http://trentm.com/projects/cmdln/> for more -details. -""" - -__version_info__ = (1, 1, 2) -__version__ = '.'.join(map(str, __version_info__)) - -import os -import sys -import re -import cmd -import optparse -from pprint import pprint -import sys - - - - -#---- globals - -LOOP_ALWAYS, LOOP_NEVER, LOOP_IF_EMPTY = range(3) - -# An unspecified optional argument when None is a meaningful value. -_NOT_SPECIFIED = ("Not", "Specified") - -# Pattern to match a TypeError message from a call that -# failed because of incorrect number of arguments (see -# Python/getargs.c). -_INCORRECT_NUM_ARGS_RE = re.compile( - r"(takes [\w ]+ )(\d+)( arguments? \()(\d+)( given\))") - - - -#---- exceptions - -class CmdlnError(Exception): - """A cmdln.py usage error.""" - def __init__(self, msg): - self.msg = msg - def __str__(self): - return self.msg - -class CmdlnUserError(Exception): - """An error by a user of a cmdln-based tool/shell.""" - pass - - - -#---- public methods and classes - -def alias(*aliases): - """Decorator to add aliases for Cmdln.do_* command handlers. - - Example: - class MyShell(cmdln.Cmdln): - @cmdln.alias("!", "sh") - def do_shell(self, argv): - #...implement 'shell' command - """ - def decorate(f): - if not hasattr(f, "aliases"): - f.aliases = [] - f.aliases += aliases - return f - return decorate - - -class RawCmdln(cmd.Cmd): - """An improved (on cmd.Cmd) framework for building multi-subcommand - scripts (think "svn" & "cvs") and simple shells (think "pdb" and - "gdb"). - - A simple example: - - import cmdln - - class MySVN(cmdln.RawCmdln): - name = "svn" - - @cmdln.aliases('stat', 'st') - def do_status(self, argv): - print "handle 'svn status' command" - - if __name__ == "__main__": - shell = MySVN() - retval = shell.main() - sys.exit(retval) - - See <http://trentm.com/projects/cmdln> for more information. - """ - name = None # if unset, defaults basename(sys.argv[0]) - prompt = None # if unset, defaults to self.name+"> " - version = None # if set, default top-level options include --version - - # Default messages for some 'help' command error cases. - # They are interpolated with one arg: the command. - nohelp = "no help on '%s'" - unknowncmd = "unknown command: '%s'" - - helpindent = '' # string with which to indent help output - - def __init__(self, completekey='tab', - stdin=None, stdout=None, stderr=None): - """Cmdln(completekey='tab', stdin=None, stdout=None, stderr=None) - - The optional argument 'completekey' is the readline name of a - completion key; it defaults to the Tab key. If completekey is - not None and the readline module is available, command completion - is done automatically. - - The optional arguments 'stdin', 'stdout' and 'stderr' specify - alternate input, output and error output file objects; if not - specified, sys.* are used. - - If 'stdout' but not 'stderr' is specified, stdout is used for - error output. This is to provide least surprise for users used - to only the 'stdin' and 'stdout' options with cmd.Cmd. - """ - import sys - if self.name is None: - self.name = os.path.basename(sys.argv[0]) - if self.prompt is None: - self.prompt = self.name+"> " - self._name_str = self._str(self.name) - self._prompt_str = self._str(self.prompt) - if stdin is not None: - self.stdin = stdin - else: - self.stdin = sys.stdin - if stdout is not None: - self.stdout = stdout - else: - self.stdout = sys.stdout - if stderr is not None: - self.stderr = stderr - elif stdout is not None: - self.stderr = stdout - else: - self.stderr = sys.stderr - self.cmdqueue = [] - self.completekey = completekey - self.cmdlooping = False - - def get_optparser(self): - """Hook for subclasses to set the option parser for the - top-level command/shell. - - This option parser is used retrieved and used by `.main()' to - handle top-level options. - - The default implements a single '-h|--help' option. Sub-classes - can return None to have no options at the top-level. Typically - an instance of CmdlnOptionParser should be returned. - """ - version = (self.version is not None - and "%s %s" % (self._name_str, self.version) - or None) - return CmdlnOptionParser(self, version=version) - - def postoptparse(self): - """Hook method executed just after `.main()' parses top-level - options. - - When called `self.options' holds the results of the option parse. - """ - pass - - def main(self, argv=None, loop=LOOP_NEVER): - """A possible mainline handler for a script, like so: - - import cmdln - class MyCmd(cmdln.Cmdln): - name = "mycmd" - ... - - if __name__ == "__main__": - MyCmd().main() - - By default this will use sys.argv to issue a single command to - 'MyCmd', then exit. The 'loop' argument can be use to control - interactive shell behaviour. - - Arguments: - "argv" (optional, default sys.argv) is the command to run. - It must be a sequence, where the first element is the - command name and subsequent elements the args for that - command. - "loop" (optional, default LOOP_NEVER) is a constant - indicating if a command loop should be started (i.e. an - interactive shell). Valid values (constants on this module): - LOOP_ALWAYS start loop and run "argv", if any - LOOP_NEVER run "argv" (or .emptyline()) and exit - LOOP_IF_EMPTY run "argv", if given, and exit; - otherwise, start loop - """ - if argv is None: - import sys - argv = sys.argv - else: - argv = argv[:] # don't modify caller's list - - self.optparser = self.get_optparser() - if self.optparser: # i.e. optparser=None means don't process for opts - try: - self.options, args = self.optparser.parse_args(argv[1:]) - except CmdlnUserError, ex: - msg = "%s: %s\nTry '%s help' for info.\n"\ - % (self.name, ex, self.name) - self.stderr.write(self._str(msg)) - self.stderr.flush() - return 1 - except StopOptionProcessing, ex: - return 0 - else: - self.options, args = None, argv[1:] - self.postoptparse() - - if loop == LOOP_ALWAYS: - if args: - self.cmdqueue.append(args) - return self.cmdloop() - elif loop == LOOP_NEVER: - if args: - return self.cmd(args) - else: - return self.emptyline() - elif loop == LOOP_IF_EMPTY: - if args: - return self.cmd(args) - else: - return self.cmdloop() - - def cmd(self, argv): - """Run one command and exit. - - "argv" is the arglist for the command to run. argv[0] is the - command to run. If argv is an empty list then the - 'emptyline' handler is run. - - Returns the return value from the command handler. - """ - assert isinstance(argv, (list, tuple)), \ - "'argv' is not a sequence: %r" % argv - retval = None - try: - argv = self.precmd(argv) - retval = self.onecmd(argv) - self.postcmd(argv) - except: - if not self.cmdexc(argv): - raise - retval = 1 - return retval - - def _str(self, s): - """Safely convert the given str/unicode to a string for printing.""" - try: - return str(s) - except UnicodeError: - #XXX What is the proper encoding to use here? 'utf-8' seems - # to work better than "getdefaultencoding" (usually - # 'ascii'), on OS X at least. - #import sys - #return s.encode(sys.getdefaultencoding(), "replace") - return s.encode("utf-8", "replace") - - def cmdloop(self, intro=None): - """Repeatedly issue a prompt, accept input, parse into an argv, and - dispatch (via .precmd(), .onecmd() and .postcmd()), passing them - the argv. In other words, start a shell. - - "intro" (optional) is a introductory message to print when - starting the command loop. This overrides the class - "intro" attribute, if any. - """ - self.cmdlooping = True - self.preloop() - if self.use_rawinput and self.completekey: - try: - import readline - self.old_completer = readline.get_completer() - readline.set_completer(self.complete) - readline.parse_and_bind(self.completekey+": complete") - except ImportError: - pass - try: - if intro is None: - intro = self.intro - if intro: - intro_str = self._str(intro) - self.stdout.write(intro_str+'\n') - self.stop = False - retval = None - while not self.stop: - if self.cmdqueue: - argv = self.cmdqueue.pop(0) - assert isinstance(argv, (list, tuple)), \ - "item on 'cmdqueue' is not a sequence: %r" % argv - else: - if self.use_rawinput: - try: - line = raw_input(self._prompt_str) - except EOFError: - line = 'EOF' - else: - self.stdout.write(self._prompt_str) - self.stdout.flush() - line = self.stdin.readline() - if not len(line): - line = 'EOF' - else: - line = line[:-1] # chop '\n' - argv = line2argv(line) - try: - argv = self.precmd(argv) - retval = self.onecmd(argv) - self.postcmd(argv) - except: - if not self.cmdexc(argv): - raise - retval = 1 - self.lastretval = retval - self.postloop() - finally: - if self.use_rawinput and self.completekey: - try: - import readline - readline.set_completer(self.old_completer) - except ImportError: - pass - self.cmdlooping = False - return retval - - def precmd(self, argv): - """Hook method executed just before the command argv is - interpreted, but after the input prompt is generated and issued. - - "argv" is the cmd to run. - - Returns an argv to run (i.e. this method can modify the command - to run). - """ - return argv - - def postcmd(self, argv): - """Hook method executed just after a command dispatch is finished. - - "argv" is the command that was run. - """ - pass - - def cmdexc(self, argv): - """Called if an exception is raised in any of precmd(), onecmd(), - or postcmd(). If True is returned, the exception is deemed to have - been dealt with. Otherwise, the exception is re-raised. - - The default implementation handles CmdlnUserError's, which - typically correspond to user error in calling commands (as - opposed to programmer error in the design of the script using - cmdln.py). - """ - import sys - type, exc, traceback = sys.exc_info() - if isinstance(exc, CmdlnUserError): - msg = "%s %s: %s\nTry '%s help %s' for info.\n"\ - % (self.name, argv[0], exc, self.name, argv[0]) - self.stderr.write(self._str(msg)) - self.stderr.flush() - return True - - def onecmd(self, argv): - if not argv: - return self.emptyline() - self.lastcmd = argv - cmdname = self._get_canonical_cmd_name(argv[0]) - if cmdname: - handler = self._get_cmd_handler(cmdname) - if handler: - return self._dispatch_cmd(handler, argv) - return self.default(argv) - - def _dispatch_cmd(self, handler, argv): - return handler(argv) - - def default(self, argv): - """Hook called to handle a command for which there is no handler. - - "argv" is the command and arguments to run. - - The default implementation writes and error message to stderr - and returns an error exit status. - - Returns a numeric command exit status. - """ - errmsg = self._str(self.unknowncmd % (argv[0],)) - if self.cmdlooping: - self.stderr.write(errmsg+"\n") - else: - self.stderr.write("%s: %s\nTry '%s help' for info.\n" - % (self._name_str, errmsg, self._name_str)) - self.stderr.flush() - return 1 - - def parseline(self, line): - # This is used by Cmd.complete (readline completer function) to - # massage the current line buffer before completion processing. - # We override to drop special '!' handling. - line = line.strip() - if not line: - return None, None, line - elif line[0] == '?': - line = 'help ' + line[1:] - i, n = 0, len(line) - while i < n and line[i] in self.identchars: i = i+1 - cmd, arg = line[:i], line[i:].strip() - return cmd, arg, line - - def helpdefault(self, cmd, known): - """Hook called to handle help on a command for which there is no - help handler. - - "cmd" is the command name on which help was requested. - "known" is a boolean indicating if this command is known - (i.e. if there is a handler for it). - - Returns a return code. - """ - if known: - msg = self._str(self.nohelp % (cmd,)) - if self.cmdlooping: - self.stderr.write(msg + '\n') - else: - self.stderr.write("%s: %s\n" % (self.name, msg)) - else: - msg = self.unknowncmd % (cmd,) - if self.cmdlooping: - self.stderr.write(msg + '\n') - else: - self.stderr.write("%s: %s\n" - "Try '%s help' for info.\n" - % (self.name, msg, self.name)) - self.stderr.flush() - return 1 - - def do_help(self, argv): - """${cmd_name}: give detailed help on a specific sub-command - - Usage: - ${name} help [COMMAND] - """ - if len(argv) > 1: # asking for help on a particular command - doc = None - cmdname = self._get_canonical_cmd_name(argv[1]) or argv[1] - if not cmdname: - return self.helpdefault(argv[1], False) - else: - helpfunc = getattr(self, "help_"+cmdname, None) - if helpfunc: - doc = helpfunc() - else: - handler = self._get_cmd_handler(cmdname) - if handler: - doc = handler.__doc__ - if doc is None: - return self.helpdefault(argv[1], handler != None) - else: # bare "help" command - doc = self.__class__.__doc__ # try class docstring - if doc is None: - # Try to provide some reasonable useful default help. - if self.cmdlooping: prefix = "" - else: prefix = self.name+' ' - doc = """Usage: - %sCOMMAND [ARGS...] - %shelp [COMMAND] - - ${option_list} - ${command_list} - ${help_list} - """ % (prefix, prefix) - cmdname = None - - if doc: # *do* have help content, massage and print that - doc = self._help_reindent(doc) - doc = self._help_preprocess(doc, cmdname) - doc = doc.rstrip() + '\n' # trim down trailing space - self.stdout.write(self._str(doc)) - self.stdout.flush() - do_help.aliases = ["?"] - - def _help_reindent(self, help, indent=None): - """Hook to re-indent help strings before writing to stdout. - - "help" is the help content to re-indent - "indent" is a string with which to indent each line of the - help content after normalizing. If unspecified or None - then the default is use: the 'self.helpindent' class - attribute. By default this is the empty string, i.e. - no indentation. - - By default, all common leading whitespace is removed and then - the lot is indented by 'self.helpindent'. When calculating the - common leading whitespace the first line is ignored -- hence - help content for Conan can be written as follows and have the - expected indentation: - - def do_crush(self, ...): - '''${cmd_name}: crush your enemies, see them driven before you... - - c.f. Conan the Barbarian''' - """ - if indent is None: - indent = self.helpindent - lines = help.splitlines(0) - _dedentlines(lines, skip_first_line=True) - lines = [(indent+line).rstrip() for line in lines] - return '\n'.join(lines) - - def _help_preprocess(self, help, cmdname): - """Hook to preprocess a help string before writing to stdout. - - "help" is the help string to process. - "cmdname" is the canonical sub-command name for which help - is being given, or None if the help is not specific to a - command. - - By default the following template variables are interpolated in - help content. (Note: these are similar to Python 2.4's - string.Template interpolation but not quite.) - - ${name} - The tool's/shell's name, i.e. 'self.name'. - ${option_list} - A formatted table of options for this shell/tool. - ${command_list} - A formatted table of available sub-commands. - ${help_list} - A formatted table of additional help topics (i.e. 'help_*' - methods with no matching 'do_*' method). - ${cmd_name} - The name (and aliases) for this sub-command formatted as: - "NAME (ALIAS1, ALIAS2, ...)". - ${cmd_usage} - A formatted usage block inferred from the command function - signature. - ${cmd_option_list} - A formatted table of options for this sub-command. (This is - only available for commands using the optparse integration, - i.e. using @cmdln.option decorators or manually setting the - 'optparser' attribute on the 'do_*' method.) - - Returns the processed help. - """ - preprocessors = { - "${name}": self._help_preprocess_name, - "${option_list}": self._help_preprocess_option_list, - "${command_list}": self._help_preprocess_command_list, - "${help_list}": self._help_preprocess_help_list, - "${cmd_name}": self._help_preprocess_cmd_name, - "${cmd_usage}": self._help_preprocess_cmd_usage, - "${cmd_option_list}": self._help_preprocess_cmd_option_list, - } - - for marker, preprocessor in preprocessors.items(): - if marker in help: - help = preprocessor(help, cmdname) - return help - - def _help_preprocess_name(self, help, cmdname=None): - return help.replace("${name}", self.name) - - def _help_preprocess_option_list(self, help, cmdname=None): - marker = "${option_list}" - indent, indent_width = _get_indent(marker, help) - suffix = _get_trailing_whitespace(marker, help) - - if self.optparser: - # Setup formatting options and format. - # - Indentation of 4 is better than optparse default of 2. - # C.f. Damian Conway's discussion of this in Perl Best - # Practices. - self.optparser.formatter.indent_increment = 4 - self.optparser.formatter.current_indent = indent_width - block = self.optparser.format_option_help() + '\n' - else: - block = "" - - help = help.replace(indent+marker+suffix, block, 1) - return help - - - def _help_preprocess_command_list(self, help, cmdname=None): - marker = "${command_list}" - indent, indent_width = _get_indent(marker, help) - suffix = _get_trailing_whitespace(marker, help) - - # Find any aliases for commands. - token2canonical = self._get_canonical_map() - aliases = {} - for token, cmdname in token2canonical.items(): - if token == cmdname: continue - aliases.setdefault(cmdname, []).append(token) - - # Get the list of (non-hidden) commands and their - # documentation, if any. - cmdnames = {} # use a dict to strip duplicates - for attr in self.get_names(): - if attr.startswith("do_"): - cmdnames[attr[3:]] = True - cmdnames = cmdnames.keys() - cmdnames.sort() - linedata = [] - for cmdname in cmdnames: - if aliases.get(cmdname): - a = aliases[cmdname] - a.sort() - cmdstr = "%s (%s)" % (cmdname, ", ".join(a)) - else: - cmdstr = cmdname - doc = None - try: - helpfunc = getattr(self, 'help_'+cmdname) - except AttributeError: - handler = self._get_cmd_handler(cmdname) - if handler: - doc = handler.__doc__ - else: - doc = helpfunc() - - # Strip "${cmd_name}: " from the start of a command's doc. Best - # practice dictates that command help strings begin with this, but - # it isn't at all wanted for the command list. - to_strip = "${cmd_name}:" - if doc and doc.startswith(to_strip): - #log.debug("stripping %r from start of %s's help string", - # to_strip, cmdname) - doc = doc[len(to_strip):].lstrip() - linedata.append( (cmdstr, doc) ) - - if linedata: - subindent = indent + ' '*4 - lines = _format_linedata(linedata, subindent, indent_width+4) - block = indent + "Commands:\n" \ - + '\n'.join(lines) + "\n\n" - help = help.replace(indent+marker+suffix, block, 1) - return help - - def _gen_names_and_attrs(self): - # Inheritance says we have to look in class and - # base classes; order is not important. - names = [] - classes = [self.__class__] - while classes: - aclass = classes.pop(0) - if aclass.__bases__: - classes = classes + list(aclass.__bases__) - for name in dir(aclass): - yield (name, getattr(aclass, name)) - - def _help_preprocess_help_list(self, help, cmdname=None): - marker = "${help_list}" - indent, indent_width = _get_indent(marker, help) - suffix = _get_trailing_whitespace(marker, help) - - # Determine the additional help topics, if any. - helpnames = {} - token2cmdname = self._get_canonical_map() - for attrname, attr in self._gen_names_and_attrs(): - if not attrname.startswith("help_"): continue - helpname = attrname[5:] - if helpname not in token2cmdname: - helpnames[helpname] = attr - - if helpnames: - linedata = [(n, a.__doc__ or "") for n, a in helpnames.items()] - linedata.sort() - - subindent = indent + ' '*4 - lines = _format_linedata(linedata, subindent, indent_width+4) - block = (indent - + "Additional help topics (run `%s help TOPIC'):\n" % self.name - + '\n'.join(lines) - + "\n\n") - else: - block = '' - help = help.replace(indent+marker+suffix, block, 1) - return help - - def _help_preprocess_cmd_name(self, help, cmdname=None): - marker = "${cmd_name}" - handler = self._get_cmd_handler(cmdname) - if not handler: - raise CmdlnError("cannot preprocess '%s' into help string: " - "could not find command handler for %r" - % (marker, cmdname)) - s = cmdname - if hasattr(handler, "aliases"): - s += " (%s)" % (", ".join(handler.aliases)) - help = help.replace(marker, s) - return help - - #TODO: this only makes sense as part of the Cmdln class. - # Add hooks to add help preprocessing template vars and put - # this one on that class. - def _help_preprocess_cmd_usage(self, help, cmdname=None): - marker = "${cmd_usage}" - handler = self._get_cmd_handler(cmdname) - if not handler: - raise CmdlnError("cannot preprocess '%s' into help string: " - "could not find command handler for %r" - % (marker, cmdname)) - indent, indent_width = _get_indent(marker, help) - suffix = _get_trailing_whitespace(marker, help) - - # Extract the introspection bits we need. - func = handler.im_func - if func.func_defaults: - func_defaults = list(func.func_defaults) - else: - func_defaults = [] - co_argcount = func.func_code.co_argcount - co_varnames = func.func_code.co_varnames - co_flags = func.func_code.co_flags - CO_FLAGS_ARGS = 4 - CO_FLAGS_KWARGS = 8 - - # Adjust argcount for possible *args and **kwargs arguments. - argcount = co_argcount - if co_flags & CO_FLAGS_ARGS: argcount += 1 - if co_flags & CO_FLAGS_KWARGS: argcount += 1 - - # Determine the usage string. - usage = "%s %s" % (self.name, cmdname) - if argcount <= 2: # handler ::= do_FOO(self, argv) - usage += " [ARGS...]" - elif argcount >= 3: # handler ::= do_FOO(self, subcmd, opts, ...) - argnames = list(co_varnames[3:argcount]) - tail = "" - if co_flags & CO_FLAGS_KWARGS: - name = argnames.pop(-1) - import warnings - # There is no generally accepted mechanism for passing - # keyword arguments from the command line. Could - # *perhaps* consider: arg=value arg2=value2 ... - warnings.warn("argument '**%s' on '%s.%s' command " - "handler will never get values" - % (name, self.__class__.__name__, - func.func_name)) - if co_flags & CO_FLAGS_ARGS: - name = argnames.pop(-1) - tail = "[%s...]" % name.upper() - while func_defaults: - func_defaults.pop(-1) - name = argnames.pop(-1) - tail = "[%s%s%s]" % (name.upper(), (tail and ' ' or ''), tail) - while argnames: - name = argnames.pop(-1) - tail = "%s %s" % (name.upper(), tail) - usage += ' ' + tail - - block_lines = [ - self.helpindent + "Usage:", - self.helpindent + ' '*4 + usage - ] - block = '\n'.join(block_lines) + '\n\n' - - help = help.replace(indent+marker+suffix, block, 1) - return help - - #TODO: this only makes sense as part of the Cmdln class. - # Add hooks to add help preprocessing template vars and put - # this one on that class. - def _help_preprocess_cmd_option_list(self, help, cmdname=None): - marker = "${cmd_option_list}" - handler = self._get_cmd_handler(cmdname) - if not handler: - raise CmdlnError("cannot preprocess '%s' into help string: " - "could not find command handler for %r" - % (marker, cmdname)) - indent, indent_width = _get_indent(marker, help) - suffix = _get_trailing_whitespace(marker, help) - if hasattr(handler, "optparser"): - # Setup formatting options and format. - # - Indentation of 4 is better than optparse default of 2. - # C.f. Damian Conway's discussion of this in Perl Best - # Practices. - handler.optparser.formatter.indent_increment = 4 - handler.optparser.formatter.current_indent = indent_width - block = handler.optparser.format_option_help() + '\n' - else: - block = "" - - help = help.replace(indent+marker+suffix, block, 1) - return help - - def _get_canonical_cmd_name(self, token): - map = self._get_canonical_map() - return map.get(token, None) - - def _get_canonical_map(self): - """Return a mapping of available command names and aliases to - their canonical command name. - """ - cacheattr = "_token2canonical" - if not hasattr(self, cacheattr): - # Get the list of commands and their aliases, if any. - token2canonical = {} - cmd2funcname = {} # use a dict to strip duplicates - for attr in self.get_names(): - if attr.startswith("do_"): cmdname = attr[3:] - elif attr.startswith("_do_"): cmdname = attr[4:] - else: - continue - cmd2funcname[cmdname] = attr - token2canonical[cmdname] = cmdname - for cmdname, funcname in cmd2funcname.items(): # add aliases - func = getattr(self, funcname) - aliases = getattr(func, "aliases", []) - for alias in aliases: - if alias in cmd2funcname: - import warnings - warnings.warn("'%s' alias for '%s' command conflicts " - "with '%s' handler" - % (alias, cmdname, cmd2funcname[alias])) - continue - token2canonical[alias] = cmdname - setattr(self, cacheattr, token2canonical) - return getattr(self, cacheattr) - - def _get_cmd_handler(self, cmdname): - handler = None - try: - handler = getattr(self, 'do_' + cmdname) - except AttributeError: - try: - # Private command handlers begin with "_do_". - handler = getattr(self, '_do_' + cmdname) - except AttributeError: - pass - return handler - - def _do_EOF(self, argv): - # Default EOF handler - # Note: an actual EOF is redirected to this command. - #TODO: separate name for this. Currently it is available from - # command-line. Is that okay? - self.stdout.write('\n') - self.stdout.flush() - self.stop = True - - def emptyline(self): - # Different from cmd.Cmd: don't repeat the last command for an - # emptyline. - if self.cmdlooping: - pass - else: - return self.do_help(["help"]) - - -#---- optparse.py extension to fix (IMO) some deficiencies -# -# See the class _OptionParserEx docstring for details. -# - -class StopOptionProcessing(Exception): - """Indicate that option *and argument* processing should stop - cleanly. This is not an error condition. It is similar in spirit to - StopIteration. This is raised by _OptionParserEx's default "help" - and "version" option actions and can be raised by custom option - callbacks too. - - Hence the typical CmdlnOptionParser (a subclass of _OptionParserEx) - usage is: - - parser = CmdlnOptionParser(mycmd) - parser.add_option("-f", "--force", dest="force") - ... - try: - opts, args = parser.parse_args() - except StopOptionProcessing: - # normal termination, "--help" was probably given - sys.exit(0) - """ - -class _OptionParserEx(optparse.OptionParser): - """An optparse.OptionParser that uses exceptions instead of sys.exit. - - This class is an extension of optparse.OptionParser that differs - as follows: - - Correct (IMO) the default OptionParser error handling to never - sys.exit(). Instead OptParseError exceptions are passed through. - - Add the StopOptionProcessing exception (a la StopIteration) to - indicate normal termination of option processing. - See StopOptionProcessing's docstring for details. - - I'd also like to see the following in the core optparse.py, perhaps - as a RawOptionParser which would serve as a base class for the more - generally used OptionParser (that works as current): - - Remove the implicit addition of the -h|--help and --version - options. They can get in the way (e.g. if want '-?' and '-V' for - these as well) and it is not hard to do: - optparser.add_option("-h", "--help", action="help") - optparser.add_option("--version", action="version") - These are good practices, just not valid defaults if they can - get in the way. - """ - def error(self, msg): - raise optparse.OptParseError(msg) - - def exit(self, status=0, msg=None): - if status == 0: - raise StopOptionProcessing(msg) - else: - #TODO: don't lose status info here - raise optparse.OptParseError(msg) - - - -#---- optparse.py-based option processing support - -class CmdlnOptionParser(_OptionParserEx): - """An optparse.OptionParser class more appropriate for top-level - Cmdln options. For parsing of sub-command options, see - SubCmdOptionParser. - - Changes: - - disable_interspersed_args() by default, because a Cmdln instance - has sub-commands which may themselves have options. - - Redirect print_help() to the Cmdln.do_help() which is better - equiped to handle the "help" action. - - error() will raise a CmdlnUserError: OptionParse.error() is meant - to be called for user errors. Raising a well-known error here can - make error handling clearer. - - Also see the changes in _OptionParserEx. - """ - def __init__(self, cmdln, **kwargs): - self.cmdln = cmdln - kwargs["prog"] = self.cmdln.name - _OptionParserEx.__init__(self, **kwargs) - self.disable_interspersed_args() - - def print_help(self, file=None): - self.cmdln.onecmd(["help"]) - - def error(self, msg): - raise CmdlnUserError(msg) - - -class SubCmdOptionParser(_OptionParserEx): - def set_cmdln_info(self, cmdln, subcmd): - """Called by Cmdln to pass relevant info about itself needed - for print_help(). - """ - self.cmdln = cmdln - self.subcmd = subcmd - - def print_help(self, file=None): - self.cmdln.onecmd(["help", self.subcmd]) - - def error(self, msg): - raise CmdlnUserError(msg) - - -def option(*args, **kwargs): - """Decorator to add an option to the optparser argument of a Cmdln - subcommand. - - Example: - class MyShell(cmdln.Cmdln): - @cmdln.option("-f", "--force", help="force removal") - def do_remove(self, subcmd, opts, *args): - #... - """ - #XXX Is there a possible optimization for many options to not have a - # large stack depth here? - def decorate(f): - if not hasattr(f, "optparser"): - f.optparser = SubCmdOptionParser() - f.optparser.add_option(*args, **kwargs) - return f - return decorate - - -class Cmdln(RawCmdln): - """An improved (on cmd.Cmd) framework for building multi-subcommand - scripts (think "svn" & "cvs") and simple shells (think "pdb" and - "gdb"). - - A simple example: - - import cmdln - - class MySVN(cmdln.Cmdln): - name = "svn" - - @cmdln.aliases('stat', 'st') - @cmdln.option('-v', '--verbose', action='store_true' - help='print verbose information') - def do_status(self, subcmd, opts, *paths): - print "handle 'svn status' command" - - #... - - if __name__ == "__main__": - shell = MySVN() - retval = shell.main() - sys.exit(retval) - - 'Cmdln' extends 'RawCmdln' by providing optparse option processing - integration. See this class' _dispatch_cmd() docstring and - <http://trentm.com/projects/cmdln> for more information. - """ - def _dispatch_cmd(self, handler, argv): - """Introspect sub-command handler signature to determine how to - dispatch the command. The raw handler provided by the base - 'RawCmdln' class is still supported: - - def do_foo(self, argv): - # 'argv' is the vector of command line args, argv[0] is - # the command name itself (i.e. "foo" or an alias) - pass - - In addition, if the handler has more than 2 arguments option - processing is automatically done (using optparse): - - @cmdln.option('-v', '--verbose', action='store_true') - def do_bar(self, subcmd, opts, *args): - # subcmd = <"bar" or an alias> - # opts = <an optparse.Values instance> - if opts.verbose: - print "lots of debugging output..." - # args = <tuple of arguments> - for arg in args: - bar(arg) - - TODO: explain that "*args" can be other signatures as well. - - The `cmdln.option` decorator corresponds to an `add_option()` - method call on an `optparse.OptionParser` instance. - - You can declare a specific number of arguments: - - @cmdln.option('-v', '--verbose', action='store_true') - def do_bar2(self, subcmd, opts, bar_one, bar_two): - #... - - and an appropriate error message will be raised/printed if the - command is called with a different number of args. - """ - co_argcount = handler.im_func.func_code.co_argcount - if co_argcount == 2: # handler ::= do_foo(self, argv) - return handler(argv) - elif co_argcount >= 3: # handler ::= do_foo(self, subcmd, opts, ...) - try: - optparser = handler.optparser - except AttributeError: - optparser = handler.im_func.optparser = SubCmdOptionParser() - assert isinstance(optparser, SubCmdOptionParser) - optparser.set_cmdln_info(self, argv[0]) - try: - opts, args = optparser.parse_args(argv[1:]) - except StopOptionProcessing: - #TODO: this doesn't really fly for a replacement of - # optparse.py behaviour, does it? - return 0 # Normal command termination - - try: - return handler(argv[0], opts, *args) - except TypeError, ex: - # Some TypeError's are user errors: - # do_foo() takes at least 4 arguments (3 given) - # do_foo() takes at most 5 arguments (6 given) - # do_foo() takes exactly 5 arguments (6 given) - # Raise CmdlnUserError for these with a suitably - # massaged error message. - import sys - tb = sys.exc_info()[2] # the traceback object - if tb.tb_next is not None: - # If the traceback is more than one level deep, then the - # TypeError do *not* happen on the "handler(...)" call - # above. In that we don't want to handle it specially - # here: it would falsely mask deeper code errors. - raise - msg = ex.args[0] - match = _INCORRECT_NUM_ARGS_RE.search(msg) - if match: - msg = list(match.groups()) - msg[1] = int(msg[1]) - 3 - if msg[1] == 1: - msg[2] = msg[2].replace("arguments", "argument") - msg[3] = int(msg[3]) - 3 - msg = ''.join(map(str, msg)) - raise CmdlnUserError(msg) - else: - raise - else: - raise CmdlnError("incorrect argcount for %s(): takes %d, must " - "take 2 for 'argv' signature or 3+ for 'opts' " - "signature" % (handler.__name__, co_argcount)) - - - -#---- internal support functions - -def _format_linedata(linedata, indent, indent_width): - """Format specific linedata into a pleasant layout. - - "linedata" is a list of 2-tuples of the form: - (<item-display-string>, <item-docstring>) - "indent" is a string to use for one level of indentation - "indent_width" is a number of columns by which the - formatted data will be indented when printed. - - The <item-display-string> column is held to 15 columns. - """ - lines = [] - WIDTH = 78 - indent_width - SPACING = 2 - NAME_WIDTH_LOWER_BOUND = 13 - NAME_WIDTH_UPPER_BOUND = 16 - NAME_WIDTH = max([len(s) for s,d in linedata]) - if NAME_WIDTH < NAME_WIDTH_LOWER_BOUND: - NAME_WIDTH = NAME_WIDTH_LOWER_BOUND - else: - NAME_WIDTH = NAME_WIDTH_UPPER_BOUND - - DOC_WIDTH = WIDTH - NAME_WIDTH - SPACING - for namestr, doc in linedata: - line = indent + namestr - if len(namestr) <= NAME_WIDTH: - line += ' ' * (NAME_WIDTH + SPACING - len(namestr)) - else: - lines.append(line) - line = indent + ' ' * (NAME_WIDTH + SPACING) - line += _summarize_doc(doc, DOC_WIDTH) - lines.append(line.rstrip()) - return lines - -def _summarize_doc(doc, length=60): - r"""Parse out a short one line summary from the given doclines. - - "doc" is the doc string to summarize. - "length" is the max length for the summary - - >>> _summarize_doc("this function does this") - 'this function does this' - >>> _summarize_doc("this function does this", 10) - 'this fu...' - >>> _summarize_doc("this function does this\nand that") - 'this function does this and that' - >>> _summarize_doc("this function does this\n\nand that") - 'this function does this' - """ - import re - if doc is None: - return "" - assert length > 3, "length <= 3 is absurdly short for a doc summary" - doclines = doc.strip().splitlines(0) - if not doclines: - return "" - - summlines = [] - for i, line in enumerate(doclines): - stripped = line.strip() - if not stripped: - break - summlines.append(stripped) - if len(''.join(summlines)) >= length: - break - - summary = ' '.join(summlines) - if len(summary) > length: - summary = summary[:length-3] + "..." - return summary - - -def line2argv(line): - r"""Parse the given line into an argument vector. - - "line" is the line of input to parse. - - This may get niggly when dealing with quoting and escaping. The - current state of this parsing may not be completely thorough/correct - in this respect. - - >>> from cmdln import line2argv - >>> line2argv("foo") - ['foo'] - >>> line2argv("foo bar") - ['foo', 'bar'] - >>> line2argv("foo bar ") - ['foo', 'bar'] - >>> line2argv(" foo bar") - ['foo', 'bar'] - - Quote handling: - - >>> line2argv("'foo bar'") - ['foo bar'] - >>> line2argv('"foo bar"') - ['foo bar'] - >>> line2argv(r'"foo\"bar"') - ['foo"bar'] - >>> line2argv("'foo bar' spam") - ['foo bar', 'spam'] - >>> line2argv("'foo 'bar spam") - ['foo bar', 'spam'] - - >>> line2argv('some\tsimple\ttests') - ['some', 'simple', 'tests'] - >>> line2argv('a "more complex" test') - ['a', 'more complex', 'test'] - >>> line2argv('a more="complex test of " quotes') - ['a', 'more=complex test of ', 'quotes'] - >>> line2argv('a more" complex test of " quotes') - ['a', 'more complex test of ', 'quotes'] - >>> line2argv('an "embedded \\"quote\\""') - ['an', 'embedded "quote"'] - - # Komodo bug 48027 - >>> line2argv('foo bar C:\\') - ['foo', 'bar', 'C:\\'] - - # Komodo change 127581 - >>> line2argv(r'"\test\slash" "foo bar" "foo\"bar"') - ['\\test\\slash', 'foo bar', 'foo"bar'] - - # Komodo change 127629 - >>> if sys.platform == "win32": - ... line2argv(r'\foo\bar') == ['\\foo\\bar'] - ... line2argv(r'\\foo\\bar') == ['\\\\foo\\\\bar'] - ... line2argv('"foo') == ['foo'] - ... else: - ... line2argv(r'\foo\bar') == ['foobar'] - ... line2argv(r'\\foo\\bar') == ['\\foo\\bar'] - ... try: - ... line2argv('"foo') - ... except ValueError, ex: - ... "not terminated" in str(ex) - True - True - True - """ - import string - line = line.strip() - argv = [] - state = "default" - arg = None # the current argument being parsed - i = -1 - while 1: - i += 1 - if i >= len(line): break - ch = line[i] - - if ch == "\\" and i+1 < len(line): - # escaped char always added to arg, regardless of state - if arg is None: arg = "" - if (sys.platform == "win32" - or state in ("double-quoted", "single-quoted") - ) and line[i+1] not in tuple('"\''): - arg += ch - i += 1 - arg += line[i] - continue - - if state == "single-quoted": - if ch == "'": - state = "default" - else: - arg += ch - elif state == "double-quoted": - if ch == '"': - state = "default" - else: - arg += ch - elif state == "default": - if ch == '"': - if arg is None: arg = "" - state = "double-quoted" - elif ch == "'": - if arg is None: arg = "" - state = "single-quoted" - elif ch in string.whitespace: - if arg is not None: - argv.append(arg) - arg = None - else: - if arg is None: arg = "" - arg += ch - if arg is not None: - argv.append(arg) - if not sys.platform == "win32" and state != "default": - raise ValueError("command line is not terminated: unfinished %s " - "segment" % state) - return argv - - -def argv2line(argv): - r"""Put together the given argument vector into a command line. - - "argv" is the argument vector to process. - - >>> from cmdln import argv2line - >>> argv2line(['foo']) - 'foo' - >>> argv2line(['foo', 'bar']) - 'foo bar' - >>> argv2line(['foo', 'bar baz']) - 'foo "bar baz"' - >>> argv2line(['foo"bar']) - 'foo"bar' - >>> print argv2line(['foo" bar']) - 'foo" bar' - >>> print argv2line(["foo' bar"]) - "foo' bar" - >>> argv2line(["foo'bar"]) - "foo'bar" - """ - escapedArgs = [] - for arg in argv: - if ' ' in arg and '"' not in arg: - arg = '"'+arg+'"' - elif ' ' in arg and "'" not in arg: - arg = "'"+arg+"'" - elif ' ' in arg: - arg = arg.replace('"', r'\"') - arg = '"'+arg+'"' - escapedArgs.append(arg) - return ' '.join(escapedArgs) - - -# Recipe: dedent (0.1) in /Users/trentm/tm/recipes/cookbook -def _dedentlines(lines, tabsize=8, skip_first_line=False): - """_dedentlines(lines, tabsize=8, skip_first_line=False) -> dedented lines - - "lines" is a list of lines to dedent. - "tabsize" is the tab width to use for indent width calculations. - "skip_first_line" is a boolean indicating if the first line should - be skipped for calculating the indent width and for dedenting. - This is sometimes useful for docstrings and similar. - - Same as dedent() except operates on a sequence of lines. Note: the - lines list is modified **in-place**. - """ - DEBUG = False - if DEBUG: - print "dedent: dedent(..., tabsize=%d, skip_first_line=%r)"\ - % (tabsize, skip_first_line) - indents = [] - margin = None - for i, line in enumerate(lines): - if i == 0 and skip_first_line: continue - indent = 0 - for ch in line: - if ch == ' ': - indent += 1 - elif ch == '\t': - indent += tabsize - (indent % tabsize) - elif ch in '\r\n': - continue # skip all-whitespace lines - else: - break - else: - continue # skip all-whitespace lines - if DEBUG: print "dedent: indent=%d: %r" % (indent, line) - if margin is None: - margin = indent - else: - margin = min(margin, indent) - if DEBUG: print "dedent: margin=%r" % margin - - if margin is not None and margin > 0: - for i, line in enumerate(lines): - if i == 0 and skip_first_line: continue - removed = 0 - for j, ch in enumerate(line): - if ch == ' ': - removed += 1 - elif ch == '\t': - removed += tabsize - (removed % tabsize) - elif ch in '\r\n': - if DEBUG: print "dedent: %r: EOL -> strip up to EOL" % line - lines[i] = lines[i][j:] - break - else: - raise ValueError("unexpected non-whitespace char %r in " - "line %r while removing %d-space margin" - % (ch, line, margin)) - if DEBUG: - print "dedent: %r: %r -> removed %d/%d"\ - % (line, ch, removed, margin) - if removed == margin: - lines[i] = lines[i][j+1:] - break - elif removed > margin: - lines[i] = ' '*(removed-margin) + lines[i][j+1:] - break - return lines - -def _dedent(text, tabsize=8, skip_first_line=False): - """_dedent(text, tabsize=8, skip_first_line=False) -> dedented text - - "text" is the text to dedent. - "tabsize" is the tab width to use for indent width calculations. - "skip_first_line" is a boolean indicating if the first line should - be skipped for calculating the indent width and for dedenting. - This is sometimes useful for docstrings and similar. - - textwrap.dedent(s), but don't expand tabs to spaces - """ - lines = text.splitlines(1) - _dedentlines(lines, tabsize=tabsize, skip_first_line=skip_first_line) - return ''.join(lines) - - -def _get_indent(marker, s, tab_width=8): - """_get_indent(marker, s, tab_width=8) -> - (<indentation-of-'marker'>, <indentation-width>)""" - # Figure out how much the marker is indented. - INDENT_CHARS = tuple(' \t') - start = s.index(marker) - i = start - while i > 0: - if s[i-1] not in INDENT_CHARS: - break - i -= 1 - indent = s[i:start] - indent_width = 0 - for ch in indent: - if ch == ' ': - indent_width += 1 - elif ch == '\t': - indent_width += tab_width - (indent_width % tab_width) - return indent, indent_width - -def _get_trailing_whitespace(marker, s): - """Return the whitespace content trailing the given 'marker' in string 's', - up to and including a newline. - """ - suffix = '' - start = s.index(marker) + len(marker) - i = start - while i < len(s): - if s[i] in ' \t': - suffix += s[i] - elif s[i] in '\r\n': - suffix += s[i] - if s[i] == '\r' and i+1 < len(s) and s[i+1] == '\n': - suffix += s[i+1] - break - else: - break - i += 1 - return suffix - - - -#---- bash completion support -# Note: This is still experimental. I expect to change this -# significantly. -# -# To get Bash completion for a cmdln.Cmdln class, run the following -# bash command: -# $ complete -C 'python -m cmdln /path/to/script.py CmdlnClass' cmdname -# For example: -# $ complete -C 'python -m cmdln ~/bin/svn.py SVN' svn -# -#TODO: Simplify the above so don't have to given path to script (try to -# find it on PATH, if possible). Could also make class name -# optional if there is only one in the module (common case). - -if __name__ == "__main__" and len(sys.argv) == 6: - def _log(s): - return # no-op, comment out for debugging - from os.path import expanduser - fout = open(expanduser("~/tmp/bashcpln.log"), 'a') - fout.write(str(s) + '\n') - fout.close() - - # Recipe: module_from_path (1.0.1+) - def _module_from_path(path): - import imp, os, sys - path = os.path.expanduser(path) - dir = os.path.dirname(path) or os.curdir - name = os.path.splitext(os.path.basename(path))[0] - sys.path.insert(0, dir) - try: - iinfo = imp.find_module(name, [dir]) - return imp.load_module(name, *iinfo) - finally: - sys.path.remove(dir) - - def _get_bash_cplns(script_path, class_name, cmd_name, - token, preceding_token): - _log('--') - _log('get_cplns(%r, %r, %r, %r, %r)' - % (script_path, class_name, cmd_name, token, preceding_token)) - comp_line = os.environ["COMP_LINE"] - comp_point = int(os.environ["COMP_POINT"]) - _log("COMP_LINE: %r" % comp_line) - _log("COMP_POINT: %r" % comp_point) - - try: - script = _module_from_path(script_path) - except ImportError, ex: - _log("error importing `%s': %s" % (script_path, ex)) - return [] - shell = getattr(script, class_name)() - cmd_map = shell._get_canonical_map() - del cmd_map["EOF"] - - # Determine if completing the sub-command name. - parts = comp_line[:comp_point].split(None, 1) - _log(parts) - if len(parts) == 1 or not (' ' in parts[1] or '\t' in parts[1]): - #TODO: if parts[1].startswith('-'): handle top-level opts - _log("complete sub-command names") - matches = {} - for name, canon_name in cmd_map.items(): - if name.startswith(token): - matches[name] = canon_name - if not matches: - return [] - elif len(matches) == 1: - return matches.keys() - elif len(set(matches.values())) == 1: - return [matches.values()[0]] - else: - return matches.keys() - - # Otherwise, complete options for the given sub-command. - #TODO: refine this so it does the right thing with option args - if token.startswith('-'): - cmd_name = comp_line.split(None, 2)[1] - try: - cmd_canon_name = cmd_map[cmd_name] - except KeyError: - return [] - handler = shell._get_cmd_handler(cmd_canon_name) - optparser = getattr(handler, "optparser", None) - if optparser is None: - optparser = SubCmdOptionParser() - opt_strs = [] - for option in optparser.option_list: - for opt_str in option._short_opts + option._long_opts: - if opt_str.startswith(token): - opt_strs.append(opt_str) - return opt_strs - - return [] - - for cpln in _get_bash_cplns(*sys.argv[1:]): - print cpln - diff --git a/scripts/lib/mic/utils/errors.py b/scripts/lib/mic/utils/errors.py deleted file mode 100644 index 8d720f9080..0000000000 --- a/scripts/lib/mic/utils/errors.py +++ /dev/null @@ -1,71 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2007 Red Hat, Inc. -# Copyright (c) 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -class CreatorError(Exception): - """An exception base class for all imgcreate errors.""" - keyword = '<creator>' - - def __init__(self, msg): - self.msg = msg - - def __str__(self): - if isinstance(self.msg, unicode): - self.msg = self.msg.encode('utf-8', 'ignore') - else: - self.msg = str(self.msg) - return self.keyword + self.msg - -class Usage(CreatorError): - keyword = '<usage>' - - def __str__(self): - if isinstance(self.msg, unicode): - self.msg = self.msg.encode('utf-8', 'ignore') - else: - self.msg = str(self.msg) - return self.keyword + self.msg + ', please use "--help" for more info' - -class Abort(CreatorError): - keyword = '' - -class ConfigError(CreatorError): - keyword = '<config>' - -class KsError(CreatorError): - keyword = '<kickstart>' - -class RepoError(CreatorError): - keyword = '<repo>' - -class RpmError(CreatorError): - keyword = '<rpm>' - -class MountError(CreatorError): - keyword = '<mount>' - -class SnapshotError(CreatorError): - keyword = '<snapshot>' - -class SquashfsError(CreatorError): - keyword = '<squashfs>' - -class BootstrapError(CreatorError): - keyword = '<bootstrap>' - -class RuntimeError(CreatorError): - keyword = '<runtime>' diff --git a/scripts/lib/mic/utils/fs_related.py b/scripts/lib/mic/utils/fs_related.py deleted file mode 100644 index dd420e88dc..0000000000 --- a/scripts/lib/mic/utils/fs_related.py +++ /dev/null @@ -1,1060 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2007, Red Hat, Inc. -# Copyright (c) 2009, 2010, 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -from __future__ import with_statement -import os -import sys -import errno -import stat -import random -import string -import time -import uuid - -from mic import msger -from mic.utils import runner -from mic.utils.errors import * -from mic.utils.oe.misc import * - -def find_binary_inchroot(binary, chroot): - paths = ["/usr/sbin", - "/usr/bin", - "/sbin", - "/bin" - ] - - for path in paths: - bin_path = "%s/%s" % (path, binary) - if os.path.exists("%s/%s" % (chroot, bin_path)): - return bin_path - return None - -def find_binary_path(binary): - if os.environ.has_key("PATH"): - paths = os.environ["PATH"].split(":") - else: - paths = [] - if os.environ.has_key("HOME"): - paths += [os.environ["HOME"] + "/bin"] - paths += ["/usr/local/sbin", "/usr/local/bin", "/usr/sbin", "/usr/bin", "/sbin", "/bin"] - - for path in paths: - bin_path = "%s/%s" % (path, binary) - if os.path.exists(bin_path): - return bin_path - - print "External command '%s' not found, exiting." % binary - print " (Please install '%s' on your host system)" % binary - sys.exit(1) - -def makedirs(dirname): - """A version of os.makedirs() that doesn't throw an - exception if the leaf directory already exists. - """ - try: - os.makedirs(dirname) - except OSError, err: - if err.errno != errno.EEXIST: - raise - -def mksquashfs(in_img, out_img): - fullpathmksquashfs = find_binary_path("mksquashfs") - args = [fullpathmksquashfs, in_img, out_img] - - if not sys.stdout.isatty(): - args.append("-no-progress") - - ret = runner.show(args) - if ret != 0: - raise SquashfsError("'%s' exited with error (%d)" % (' '.join(args), ret)) - -def resize2fs(fs, size): - resize2fs = find_binary_path("resize2fs") - if size == 0: - # it means to minimalize it - return runner.show([resize2fs, '-M', fs]) - else: - return runner.show([resize2fs, fs, "%sK" % (size / 1024,)]) - -def my_fuser(fp): - fuser = find_binary_path("fuser") - if not os.path.exists(fp): - return False - - rc = runner.quiet([fuser, "-s", fp]) - if rc == 0: - for pid in runner.outs([fuser, fp]).split(): - fd = open("/proc/%s/cmdline" % pid, "r") - cmdline = fd.read() - fd.close() - if cmdline[:-1] == "/bin/bash": - return True - - # not found - return False - -class BindChrootMount: - """Represents a bind mount of a directory into a chroot.""" - def __init__(self, src, chroot, dest = None, option = None): - self.root = os.path.abspath(os.path.expanduser(chroot)) - self.option = option - - self.orig_src = self.src = src - if os.path.islink(src): - self.src = os.readlink(src) - if not self.src.startswith('/'): - self.src = os.path.abspath(os.path.join(os.path.dirname(src), - self.src)) - - if not dest: - dest = self.src - self.dest = os.path.join(self.root, dest.lstrip('/')) - - self.mounted = False - self.mountcmd = find_binary_path("mount") - self.umountcmd = find_binary_path("umount") - - def ismounted(self): - with open('/proc/mounts') as f: - for line in f: - if line.split()[1] == os.path.abspath(self.dest): - return True - - return False - - def has_chroot_instance(self): - lock = os.path.join(self.root, ".chroot.lock") - return my_fuser(lock) - - def mount(self): - if self.mounted or self.ismounted(): - return - - makedirs(self.dest) - rc = runner.show([self.mountcmd, "--bind", self.src, self.dest]) - if rc != 0: - raise MountError("Bind-mounting '%s' to '%s' failed" % - (self.src, self.dest)) - if self.option: - rc = runner.show([self.mountcmd, "--bind", "-o", "remount,%s" % self.option, self.dest]) - if rc != 0: - raise MountError("Bind-remounting '%s' failed" % self.dest) - - self.mounted = True - if os.path.islink(self.orig_src): - dest = os.path.join(self.root, self.orig_src.lstrip('/')) - if not os.path.exists(dest): - os.symlink(self.src, dest) - - def unmount(self): - if self.has_chroot_instance(): - return - - if self.ismounted(): - runner.show([self.umountcmd, "-l", self.dest]) - self.mounted = False - -class LoopbackMount: - """LoopbackMount compatibility layer for old API""" - def __init__(self, lofile, mountdir, fstype = None): - self.diskmount = DiskMount(LoopbackDisk(lofile,size = 0),mountdir,fstype,rmmountdir = True) - self.losetup = False - self.losetupcmd = find_binary_path("losetup") - - def cleanup(self): - self.diskmount.cleanup() - - def unmount(self): - self.diskmount.unmount() - - def lounsetup(self): - if self.losetup: - runner.show([self.losetupcmd, "-d", self.loopdev]) - self.losetup = False - self.loopdev = None - - def loopsetup(self): - if self.losetup: - return - - self.loopdev = get_loop_device(self.losetupcmd, self.lofile) - self.losetup = True - - def mount(self): - self.diskmount.mount() - -class SparseLoopbackMount(LoopbackMount): - """SparseLoopbackMount compatibility layer for old API""" - def __init__(self, lofile, mountdir, size, fstype = None): - self.diskmount = DiskMount(SparseLoopbackDisk(lofile,size),mountdir,fstype,rmmountdir = True) - - def expand(self, create = False, size = None): - self.diskmount.disk.expand(create, size) - - def truncate(self, size = None): - self.diskmount.disk.truncate(size) - - def create(self): - self.diskmount.disk.create() - -class SparseExtLoopbackMount(SparseLoopbackMount): - """SparseExtLoopbackMount compatibility layer for old API""" - def __init__(self, lofile, mountdir, size, fstype, blocksize, fslabel): - self.diskmount = ExtDiskMount(SparseLoopbackDisk(lofile,size), mountdir, fstype, blocksize, fslabel, rmmountdir = True) - - - def __format_filesystem(self): - self.diskmount.__format_filesystem() - - def create(self): - self.diskmount.disk.create() - - def resize(self, size = None): - return self.diskmount.__resize_filesystem(size) - - def mount(self): - self.diskmount.mount() - - def __fsck(self): - self.extdiskmount.__fsck() - - def __get_size_from_filesystem(self): - return self.diskmount.__get_size_from_filesystem() - - def __resize_to_minimal(self): - return self.diskmount.__resize_to_minimal() - - def resparse(self, size = None): - return self.diskmount.resparse(size) - -class Disk: - """Generic base object for a disk - - The 'create' method must make the disk visible as a block device - eg - by calling losetup. For RawDisk, this is obviously a no-op. The 'cleanup' - method must undo the 'create' operation. - """ - def __init__(self, size, device = None): - self._device = device - self._size = size - - def create(self): - pass - - def cleanup(self): - pass - - def get_device(self): - return self._device - def set_device(self, path): - self._device = path - device = property(get_device, set_device) - - def get_size(self): - return self._size - size = property(get_size) - - -class RawDisk(Disk): - """A Disk backed by a block device. - Note that create() is a no-op. - """ - def __init__(self, size, device): - Disk.__init__(self, size, device) - - def fixed(self): - return True - - def exists(self): - return True - - -class DiskImage(Disk): - """ - A Disk backed by a file. - """ - def __init__(self, image_file, size): - Disk.__init__(self, size) - self.image_file = image_file - - def exists(self): - return os.path.exists(self.image_file) - - def create(self): - if self.device is not None: - return - - blocks = self.size / 1024 - if self.size - blocks * 1024: - blocks += 1 - - # create disk image - dd_cmd = "dd if=/dev/zero of=%s bs=1024 seek=%d count=1" % \ - (self.image_file, blocks) - rc, out = exec_cmd(dd_cmd) - - self.device = self.image_file - - -class LoopbackDisk(Disk): - """A Disk backed by a file via the loop module.""" - def __init__(self, lofile, size): - Disk.__init__(self, size) - self.lofile = lofile - self.losetupcmd = find_binary_path("losetup") - - def fixed(self): - return False - - def exists(self): - return os.path.exists(self.lofile) - - def create(self): - if self.device is not None: - return - - self.device = get_loop_device(self.losetupcmd, self.lofile) - - def cleanup(self): - if self.device is None: - return - msger.debug("Losetup remove %s" % self.device) - rc = runner.show([self.losetupcmd, "-d", self.device]) - self.device = None - -class SparseLoopbackDisk(LoopbackDisk): - """A Disk backed by a sparse file via the loop module.""" - def __init__(self, lofile, size): - LoopbackDisk.__init__(self, lofile, size) - - def expand(self, create = False, size = None): - flags = os.O_WRONLY - if create: - flags |= os.O_CREAT - if not os.path.exists(self.lofile): - makedirs(os.path.dirname(self.lofile)) - - if size is None: - size = self.size - - msger.debug("Extending sparse file %s to %d" % (self.lofile, size)) - if create: - fd = os.open(self.lofile, flags, 0644) - else: - fd = os.open(self.lofile, flags) - - if size <= 0: - size = 1 - try: - os.ftruncate(fd, size) - except: - # may be limited by 2G in 32bit env - os.ftruncate(fd, 2**31L) - - os.close(fd) - - def truncate(self, size = None): - if size is None: - size = self.size - - msger.debug("Truncating sparse file %s to %d" % (self.lofile, size)) - fd = os.open(self.lofile, os.O_WRONLY) - os.ftruncate(fd, size) - os.close(fd) - - def create(self): - self.expand(create = True) - LoopbackDisk.create(self) - -class Mount: - """A generic base class to deal with mounting things.""" - def __init__(self, mountdir): - self.mountdir = mountdir - - def cleanup(self): - self.unmount() - - def mount(self, options = None): - pass - - def unmount(self): - pass - -class DiskMount(Mount): - """A Mount object that handles mounting of a Disk.""" - def __init__(self, disk, mountdir, fstype = None, rmmountdir = True): - Mount.__init__(self, mountdir) - - self.disk = disk - self.fstype = fstype - self.rmmountdir = rmmountdir - - self.mounted = False - self.rmdir = False - if fstype: - self.mkfscmd = find_binary_path("mkfs." + self.fstype) - else: - self.mkfscmd = None - self.mountcmd = find_binary_path("mount") - self.umountcmd = find_binary_path("umount") - - def cleanup(self): - Mount.cleanup(self) - self.disk.cleanup() - - def unmount(self): - if self.mounted: - msger.debug("Unmounting directory %s" % self.mountdir) - runner.quiet('sync') # sync the data on this mount point - rc = runner.show([self.umountcmd, "-l", self.mountdir]) - if rc == 0: - self.mounted = False - else: - raise MountError("Failed to umount %s" % self.mountdir) - if self.rmdir and not self.mounted: - try: - os.rmdir(self.mountdir) - except OSError, e: - pass - self.rmdir = False - - - def __create(self): - self.disk.create() - - - def mount(self, options = None): - if self.mounted: - return - - if not os.path.isdir(self.mountdir): - msger.debug("Creating mount point %s" % self.mountdir) - os.makedirs(self.mountdir) - self.rmdir = self.rmmountdir - - self.__create() - - msger.debug("Mounting %s at %s" % (self.disk.device, self.mountdir)) - if options: - args = [ self.mountcmd, "-o", options, self.disk.device, self.mountdir ] - else: - args = [ self.mountcmd, self.disk.device, self.mountdir ] - if self.fstype: - args.extend(["-t", self.fstype]) - - rc = runner.show(args) - if rc != 0: - raise MountError("Failed to mount '%s' to '%s' with command '%s'. Retval: %s" % - (self.disk.device, self.mountdir, " ".join(args), rc)) - - self.mounted = True - -class ExtDiskMount(DiskMount): - """A DiskMount object that is able to format/resize ext[23] filesystems.""" - def __init__(self, disk, mountdir, fstype, blocksize, fslabel, rmmountdir=True, skipformat = False, fsopts = None): - DiskMount.__init__(self, disk, mountdir, fstype, rmmountdir) - self.blocksize = blocksize - self.fslabel = fslabel.replace("/", "") - self.uuid = str(uuid.uuid4()) - self.skipformat = skipformat - self.fsopts = fsopts - self.extopts = None - self.dumpe2fs = find_binary_path("dumpe2fs") - self.tune2fs = find_binary_path("tune2fs") - - def __parse_field(self, output, field): - for line in output.split("\n"): - if line.startswith(field + ":"): - return line[len(field) + 1:].strip() - - raise KeyError("Failed to find field '%s' in output" % field) - - def __format_filesystem(self): - if self.skipformat: - msger.debug("Skip filesystem format.") - return - - msger.verbose("Formating %s filesystem on %s" % (self.fstype, self.disk.device)) - cmdlist = [self.mkfscmd, "-F", "-L", self.fslabel, "-m", "1", "-b", - str(self.blocksize), "-U", self.uuid] - if self.extopts: - cmdlist.extend(self.extopts.split()) - cmdlist.extend([self.disk.device]) - - rc, errout = runner.runtool(cmdlist, catch=2) - if rc != 0: - raise MountError("Error creating %s filesystem on disk %s:\n%s" % - (self.fstype, self.disk.device, errout)) - - if not self.extopts: - msger.debug("Tuning filesystem on %s" % self.disk.device) - runner.show([self.tune2fs, "-c0", "-i0", "-Odir_index", "-ouser_xattr,acl", self.disk.device]) - - def __resize_filesystem(self, size = None): - current_size = os.stat(self.disk.lofile)[stat.ST_SIZE] - - if size is None: - size = self.disk.size - - if size == current_size: - return - - if size > current_size: - self.disk.expand(size) - - self.__fsck() - - resize2fs(self.disk.lofile, size) - return size - - def __create(self): - resize = False - if not self.disk.fixed() and self.disk.exists(): - resize = True - - self.disk.create() - - if resize: - self.__resize_filesystem() - else: - self.__format_filesystem() - - def mount(self, options = None): - self.__create() - DiskMount.mount(self, options) - - def __fsck(self): - msger.info("Checking filesystem %s" % self.disk.lofile) - runner.quiet(["/sbin/e2fsck", "-f", "-y", self.disk.lofile]) - - def __get_size_from_filesystem(self): - return int(self.__parse_field(runner.outs([self.dumpe2fs, '-h', self.disk.lofile]), - "Block count")) * self.blocksize - - def __resize_to_minimal(self): - self.__fsck() - - # - # Use a binary search to find the minimal size - # we can resize the image to - # - bot = 0 - top = self.__get_size_from_filesystem() - while top != (bot + 1): - t = bot + ((top - bot) / 2) - - if not resize2fs(self.disk.lofile, t): - top = t - else: - bot = t - return top - - def resparse(self, size = None): - self.cleanup() - if size == 0: - minsize = 0 - else: - minsize = self.__resize_to_minimal() - self.disk.truncate(minsize) - - self.__resize_filesystem(size) - return minsize - -class VfatDiskMount(DiskMount): - """A DiskMount object that is able to format vfat/msdos filesystems.""" - def __init__(self, disk, mountdir, fstype, blocksize, fslabel, rmmountdir=True, skipformat = False, fsopts = None): - DiskMount.__init__(self, disk, mountdir, fstype, rmmountdir) - self.blocksize = blocksize - self.fslabel = fslabel.replace("/", "") - rand1 = random.randint(0, 2**16 - 1) - rand2 = random.randint(0, 2**16 - 1) - self.uuid = "%04X-%04X" % (rand1, rand2) - self.skipformat = skipformat - self.fsopts = fsopts - self.fsckcmd = find_binary_path("fsck." + self.fstype) - - def __format_filesystem(self): - if self.skipformat: - msger.debug("Skip filesystem format.") - return - - msger.verbose("Formating %s filesystem on %s" % (self.fstype, self.disk.device)) - rc = runner.show([self.mkfscmd, "-n", self.fslabel, - "-i", self.uuid.replace("-", ""), self.disk.device]) - if rc != 0: - raise MountError("Error creating %s filesystem on disk %s" % (self.fstype,self.disk.device)) - - msger.verbose("Tuning filesystem on %s" % self.disk.device) - - def __resize_filesystem(self, size = None): - current_size = os.stat(self.disk.lofile)[stat.ST_SIZE] - - if size is None: - size = self.disk.size - - if size == current_size: - return - - if size > current_size: - self.disk.expand(size) - - self.__fsck() - - #resize2fs(self.disk.lofile, size) - return size - - def __create(self): - resize = False - if not self.disk.fixed() and self.disk.exists(): - resize = True - - self.disk.create() - - if resize: - self.__resize_filesystem() - else: - self.__format_filesystem() - - def mount(self, options = None): - self.__create() - DiskMount.mount(self, options) - - def __fsck(self): - msger.debug("Checking filesystem %s" % self.disk.lofile) - runner.show([self.fsckcmd, "-y", self.disk.lofile]) - - def __get_size_from_filesystem(self): - return self.disk.size - - def __resize_to_minimal(self): - self.__fsck() - - # - # Use a binary search to find the minimal size - # we can resize the image to - # - bot = 0 - top = self.__get_size_from_filesystem() - return top - - def resparse(self, size = None): - self.cleanup() - minsize = self.__resize_to_minimal() - self.disk.truncate(minsize) - self.__resize_filesystem(size) - return minsize - -class BtrfsDiskMount(DiskMount): - """A DiskMount object that is able to format/resize btrfs filesystems.""" - def __init__(self, disk, mountdir, fstype, blocksize, fslabel, rmmountdir=True, skipformat = False, fsopts = None): - self.__check_btrfs() - DiskMount.__init__(self, disk, mountdir, fstype, rmmountdir) - self.blocksize = blocksize - self.fslabel = fslabel.replace("/", "") - self.uuid = None - self.skipformat = skipformat - self.fsopts = fsopts - self.blkidcmd = find_binary_path("blkid") - self.btrfsckcmd = find_binary_path("btrfsck") - - def __check_btrfs(self): - found = False - """ Need to load btrfs module to mount it """ - load_module("btrfs") - for line in open("/proc/filesystems").xreadlines(): - if line.find("btrfs") > -1: - found = True - break - if not found: - raise MountError("Your system can't mount btrfs filesystem, please make sure your kernel has btrfs support and the module btrfs.ko has been loaded.") - - # disable selinux, selinux will block write - if os.path.exists("/usr/sbin/setenforce"): - runner.show(["/usr/sbin/setenforce", "0"]) - - def __parse_field(self, output, field): - for line in output.split(" "): - if line.startswith(field + "="): - return line[len(field) + 1:].strip().replace("\"", "") - - raise KeyError("Failed to find field '%s' in output" % field) - - def __format_filesystem(self): - if self.skipformat: - msger.debug("Skip filesystem format.") - return - - msger.verbose("Formating %s filesystem on %s" % (self.fstype, self.disk.device)) - rc = runner.show([self.mkfscmd, "-L", self.fslabel, self.disk.device]) - if rc != 0: - raise MountError("Error creating %s filesystem on disk %s" % (self.fstype,self.disk.device)) - - self.uuid = self.__parse_field(runner.outs([self.blkidcmd, self.disk.device]), "UUID") - - def __resize_filesystem(self, size = None): - current_size = os.stat(self.disk.lofile)[stat.ST_SIZE] - - if size is None: - size = self.disk.size - - if size == current_size: - return - - if size > current_size: - self.disk.expand(size) - - self.__fsck() - return size - - def __create(self): - resize = False - if not self.disk.fixed() and self.disk.exists(): - resize = True - - self.disk.create() - - if resize: - self.__resize_filesystem() - else: - self.__format_filesystem() - - def mount(self, options = None): - self.__create() - DiskMount.mount(self, options) - - def __fsck(self): - msger.debug("Checking filesystem %s" % self.disk.lofile) - runner.quiet([self.btrfsckcmd, self.disk.lofile]) - - def __get_size_from_filesystem(self): - return self.disk.size - - def __resize_to_minimal(self): - self.__fsck() - - return self.__get_size_from_filesystem() - - def resparse(self, size = None): - self.cleanup() - minsize = self.__resize_to_minimal() - self.disk.truncate(minsize) - self.__resize_filesystem(size) - return minsize - -class DeviceMapperSnapshot(object): - def __init__(self, imgloop, cowloop): - self.imgloop = imgloop - self.cowloop = cowloop - - self.__created = False - self.__name = None - self.dmsetupcmd = find_binary_path("dmsetup") - - """Load dm_snapshot if it isn't loaded""" - load_module("dm_snapshot") - - def get_path(self): - if self.__name is None: - return None - return os.path.join("/dev/mapper", self.__name) - path = property(get_path) - - def create(self): - if self.__created: - return - - self.imgloop.create() - self.cowloop.create() - - self.__name = "imgcreate-%d-%d" % (os.getpid(), - random.randint(0, 2**16)) - - size = os.stat(self.imgloop.lofile)[stat.ST_SIZE] - - table = "0 %d snapshot %s %s p 8" % (size / 512, - self.imgloop.device, - self.cowloop.device) - - args = [self.dmsetupcmd, "create", self.__name, "--table", table] - if runner.show(args) != 0: - self.cowloop.cleanup() - self.imgloop.cleanup() - raise SnapshotError("Could not create snapshot device using: " + ' '.join(args)) - - self.__created = True - - def remove(self, ignore_errors = False): - if not self.__created: - return - - time.sleep(2) - rc = runner.show([self.dmsetupcmd, "remove", self.__name]) - if not ignore_errors and rc != 0: - raise SnapshotError("Could not remove snapshot device") - - self.__name = None - self.__created = False - - self.cowloop.cleanup() - self.imgloop.cleanup() - - def get_cow_used(self): - if not self.__created: - return 0 - - # - # dmsetup status on a snapshot returns e.g. - # "0 8388608 snapshot 416/1048576" - # or, more generally: - # "A B snapshot C/D" - # where C is the number of 512 byte sectors in use - # - out = runner.outs([self.dmsetupcmd, "status", self.__name]) - try: - return int((out.split()[3]).split('/')[0]) * 512 - except ValueError: - raise SnapshotError("Failed to parse dmsetup status: " + out) - -def create_image_minimizer(path, image, minimal_size): - """ - Builds a copy-on-write image which can be used to - create a device-mapper snapshot of an image where - the image's filesystem is as small as possible - - The steps taken are: - 1) Create a sparse COW - 2) Loopback mount the image and the COW - 3) Create a device-mapper snapshot of the image - using the COW - 4) Resize the filesystem to the minimal size - 5) Determine the amount of space used in the COW - 6) Restroy the device-mapper snapshot - 7) Truncate the COW, removing unused space - 8) Create a squashfs of the COW - """ - imgloop = LoopbackDisk(image, None) # Passing bogus size - doesn't matter - - cowloop = SparseLoopbackDisk(os.path.join(os.path.dirname(path), "osmin"), - 64L * 1024L * 1024L) - - snapshot = DeviceMapperSnapshot(imgloop, cowloop) - - try: - snapshot.create() - - resize2fs(snapshot.path, minimal_size) - - cow_used = snapshot.get_cow_used() - finally: - snapshot.remove(ignore_errors = (not sys.exc_info()[0] is None)) - - cowloop.truncate(cow_used) - - mksquashfs(cowloop.lofile, path) - - os.unlink(cowloop.lofile) - -def load_module(module): - found = False - for line in open('/proc/modules').xreadlines(): - if line.startswith("%s " % module): - found = True - break - if not found: - msger.info("Loading %s..." % module) - runner.quiet(['modprobe', module]) - -class LoopDevice(object): - def __init__(self, loopid=None): - self.device = None - self.loopid = loopid - self.created = False - self.kpartxcmd = find_binary_path("kpartx") - self.losetupcmd = find_binary_path("losetup") - - def register(self, device): - self.device = device - self.loopid = None - self.created = True - - def reg_atexit(self): - import atexit - atexit.register(self.close) - - def _genloopid(self): - import glob - if not glob.glob("/dev/loop[0-9]*"): - return 10 - - fint = lambda x: x[9:].isdigit() and int(x[9:]) or 0 - maxid = 1 + max(filter(lambda x: x<100, - map(fint, glob.glob("/dev/loop[0-9]*")))) - if maxid < 10: maxid = 10 - if maxid >= 100: raise - return maxid - - def _kpseek(self, device): - rc, out = runner.runtool([self.kpartxcmd, '-l', '-v', device]) - if rc != 0: - raise MountError("Can't query dm snapshot on %s" % device) - for line in out.splitlines(): - if line and line.startswith("loop"): - return True - return False - - def _loseek(self, device): - import re - rc, out = runner.runtool([self.losetupcmd, '-a']) - if rc != 0: - raise MountError("Failed to run 'losetup -a'") - for line in out.splitlines(): - m = re.match("([^:]+): .*", line) - if m and m.group(1) == device: - return True - return False - - def create(self): - if not self.created: - if not self.loopid: - self.loopid = self._genloopid() - self.device = "/dev/loop%d" % self.loopid - if os.path.exists(self.device): - if self._loseek(self.device): - raise MountError("Device busy: %s" % self.device) - else: - self.created = True - return - - mknod = find_binary_path('mknod') - rc = runner.show([mknod, '-m664', self.device, 'b', '7', str(self.loopid)]) - if rc != 0: - raise MountError("Failed to create device %s" % self.device) - else: - self.created = True - - def close(self): - if self.created: - try: - self.cleanup() - self.device = None - except MountError, e: - msger.error("%s" % e) - - def cleanup(self): - - if self.device is None: - return - - - if self._kpseek(self.device): - if self.created: - for i in range(3, os.sysconf("SC_OPEN_MAX")): - try: - os.close(i) - except: - pass - runner.quiet([self.kpartxcmd, "-d", self.device]) - if self._loseek(self.device): - runner.quiet([self.losetupcmd, "-d", self.device]) - # FIXME: should sleep a while between two loseek - if self._loseek(self.device): - msger.warning("Can't cleanup loop device %s" % self.device) - elif self.loopid: - os.unlink(self.device) - -DEVICE_PIDFILE_DIR = "/var/tmp/mic/device" -DEVICE_LOCKFILE = "/var/lock/__mic_loopdev.lock" - -def get_loop_device(losetupcmd, lofile): - global DEVICE_PIDFILE_DIR - global DEVICE_LOCKFILE - - import fcntl - makedirs(os.path.dirname(DEVICE_LOCKFILE)) - fp = open(DEVICE_LOCKFILE, 'w') - fcntl.flock(fp, fcntl.LOCK_EX) - try: - loopdev = None - devinst = LoopDevice() - - # clean up left loop device first - clean_loop_devices() - - # provide an avaible loop device - rc, out = runner.runtool([losetupcmd, "--find"]) - if rc == 0: - loopdev = out.split()[0] - devinst.register(loopdev) - if not loopdev or not os.path.exists(loopdev): - devinst.create() - loopdev = devinst.device - - # setup a loop device for image file - rc = runner.show([losetupcmd, loopdev, lofile]) - if rc != 0: - raise MountError("Failed to setup loop device for '%s'" % lofile) - - devinst.reg_atexit() - - # try to save device and pid - makedirs(DEVICE_PIDFILE_DIR) - pidfile = os.path.join(DEVICE_PIDFILE_DIR, os.path.basename(loopdev)) - if os.path.exists(pidfile): - os.unlink(pidfile) - with open(pidfile, 'w') as wf: - wf.write(str(os.getpid())) - - except MountError, err: - raise CreatorError("%s" % str(err)) - except: - raise - finally: - try: - fcntl.flock(fp, fcntl.LOCK_UN) - fp.close() - os.unlink(DEVICE_LOCKFILE) - except: - pass - - return loopdev - -def clean_loop_devices(piddir=DEVICE_PIDFILE_DIR): - if not os.path.exists(piddir) or not os.path.isdir(piddir): - return - - for loopdev in os.listdir(piddir): - pidfile = os.path.join(piddir, loopdev) - try: - with open(pidfile, 'r') as rf: - devpid = int(rf.read()) - except: - devpid = None - - # if the process using this device is alive, skip it - if not devpid or os.path.exists(os.path.join('/proc', str(devpid))): - continue - - # try to clean it up - try: - devinst = LoopDevice() - devinst.register(os.path.join('/dev', loopdev)) - devinst.cleanup() - os.unlink(pidfile) - except: - pass - diff --git a/scripts/lib/mic/utils/gpt_parser.py b/scripts/lib/mic/utils/gpt_parser.py deleted file mode 100644 index 5d43b70778..0000000000 --- a/scripts/lib/mic/utils/gpt_parser.py +++ /dev/null @@ -1,331 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2013 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -""" This module implements a simple GPT partitions parser which can read the -GPT header and the GPT partition table. """ - -import struct -import uuid -import binascii -from mic.utils.errors import MountError - -_GPT_HEADER_FORMAT = "<8s4sIIIQQQQ16sQIII" -_GPT_HEADER_SIZE = struct.calcsize(_GPT_HEADER_FORMAT) -_GPT_ENTRY_FORMAT = "<16s16sQQQ72s" -_GPT_ENTRY_SIZE = struct.calcsize(_GPT_ENTRY_FORMAT) -_SUPPORTED_GPT_REVISION = '\x00\x00\x01\x00' - -def _stringify_uuid(binary_uuid): - """ A small helper function to transform a binary UUID into a string - format. """ - - uuid_str = str(uuid.UUID(bytes_le = binary_uuid)) - - return uuid_str.upper() - -def _calc_header_crc(raw_hdr): - """ Calculate GPT header CRC32 checksum. The 'raw_hdr' parameter has to - be a list or a tuple containing all the elements of the GPT header in a - "raw" form, meaning that it should simply contain "unpacked" disk data. - """ - - raw_hdr = list(raw_hdr) - raw_hdr[3] = 0 - raw_hdr = struct.pack(_GPT_HEADER_FORMAT, *raw_hdr) - - return binascii.crc32(raw_hdr) & 0xFFFFFFFF - -def _validate_header(raw_hdr): - """ Validate the GPT header. The 'raw_hdr' parameter has to be a list or a - tuple containing all the elements of the GPT header in a "raw" form, - meaning that it should simply contain "unpacked" disk data. """ - - # Validate the signature - if raw_hdr[0] != 'EFI PART': - raise MountError("GPT partition table not found") - - # Validate the revision - if raw_hdr[1] != _SUPPORTED_GPT_REVISION: - raise MountError("Unsupported GPT revision '%s', supported revision " \ - "is '%s'" % \ - (binascii.hexlify(raw_hdr[1]), - binascii.hexlify(_SUPPORTED_GPT_REVISION))) - - # Validate header size - if raw_hdr[2] != _GPT_HEADER_SIZE: - raise MountError("Bad GPT header size: %d bytes, expected %d" % \ - (raw_hdr[2], _GPT_HEADER_SIZE)) - - crc = _calc_header_crc(raw_hdr) - if raw_hdr[3] != crc: - raise MountError("GPT header crc mismatch: %#x, should be %#x" % \ - (crc, raw_hdr[3])) - -class GptParser: - """ GPT partition table parser. Allows reading the GPT header and the - partition table, as well as modifying the partition table records. """ - - def __init__(self, disk_path, sector_size = 512): - """ The class constructor which accepts the following parameters: - * disk_path - full path to the disk image or device node - * sector_size - size of a disk sector in bytes """ - - self.sector_size = sector_size - self.disk_path = disk_path - - try: - self._disk_obj = open(disk_path, 'r+b') - except IOError as err: - raise MountError("Cannot open file '%s' for reading GPT " \ - "partitions: %s" % (disk_path, err)) - - def __del__(self): - """ The class destructor. """ - - self._disk_obj.close() - - def _read_disk(self, offset, size): - """ A helper function which reads 'size' bytes from offset 'offset' of - the disk and checks all the error conditions. """ - - self._disk_obj.seek(offset) - try: - data = self._disk_obj.read(size) - except IOError as err: - raise MountError("cannot read from '%s': %s" % \ - (self.disk_path, err)) - - if len(data) != size: - raise MountError("cannot read %d bytes from offset '%d' of '%s', " \ - "read only %d bytes" % \ - (size, offset, self.disk_path, len(data))) - - return data - - def _write_disk(self, offset, buf): - """ A helper function which writes buffer 'buf' to offset 'offset' of - the disk. This function takes care of unaligned writes and checks all - the error conditions. """ - - # Since we may be dealing with a block device, we only can write in - # 'self.sector_size' chunks. Find the aligned starting and ending - # disk offsets to read. - start = (offset / self.sector_size) * self.sector_size - end = ((start + len(buf)) / self.sector_size + 1) * self.sector_size - - data = self._read_disk(start, end - start) - off = offset - start - data = data[:off] + buf + data[off + len(buf):] - - self._disk_obj.seek(start) - try: - self._disk_obj.write(data) - except IOError as err: - raise MountError("cannot write to '%s': %s" % (self.disk_path, err)) - - def read_header(self, primary = True): - """ Read and verify the GPT header and return a dictionary containing - the following elements: - - 'signature' : header signature - 'revision' : header revision - 'hdr_size' : header size in bytes - 'hdr_crc' : header CRC32 - 'hdr_lba' : LBA of this header - 'hdr_offs' : byte disk offset of this header - 'backup_lba' : backup header LBA - 'backup_offs' : byte disk offset of backup header - 'first_lba' : first usable LBA for partitions - 'first_offs' : first usable byte disk offset for partitions - 'last_lba' : last usable LBA for partitions - 'last_offs' : last usable byte disk offset for partitions - 'disk_uuid' : UUID of the disk - 'ptable_lba' : starting LBA of array of partition entries - 'ptable_offs' : disk byte offset of the start of the partition table - 'ptable_size' : partition table size in bytes - 'entries_cnt' : number of available partition table entries - 'entry_size' : size of a single partition entry - 'ptable_crc' : CRC32 of the partition table - 'primary' : a boolean, if 'True', this is the primary GPT header, - if 'False' - the secondary - 'primary_str' : contains string "primary" if this is the primary GPT - header, and "backup" otherwise - - This dictionary corresponds to the GPT header format. Please, see the - UEFI standard for the description of these fields. - - If the 'primary' parameter is 'True', the primary GPT header is read, - otherwise the backup GPT header is read instead. """ - - # Read and validate the primary GPT header - raw_hdr = self._read_disk(self.sector_size, _GPT_HEADER_SIZE) - raw_hdr = struct.unpack(_GPT_HEADER_FORMAT, raw_hdr) - _validate_header(raw_hdr) - primary_str = "primary" - - if not primary: - # Read and validate the backup GPT header - raw_hdr = self._read_disk(raw_hdr[6] * self.sector_size, _GPT_HEADER_SIZE) - raw_hdr = struct.unpack(_GPT_HEADER_FORMAT, raw_hdr) - _validate_header(raw_hdr) - primary_str = "backup" - - return { 'signature' : raw_hdr[0], - 'revision' : raw_hdr[1], - 'hdr_size' : raw_hdr[2], - 'hdr_crc' : raw_hdr[3], - 'hdr_lba' : raw_hdr[5], - 'hdr_offs' : raw_hdr[5] * self.sector_size, - 'backup_lba' : raw_hdr[6], - 'backup_offs' : raw_hdr[6] * self.sector_size, - 'first_lba' : raw_hdr[7], - 'first_offs' : raw_hdr[7] * self.sector_size, - 'last_lba' : raw_hdr[8], - 'last_offs' : raw_hdr[8] * self.sector_size, - 'disk_uuid' :_stringify_uuid(raw_hdr[9]), - 'ptable_lba' : raw_hdr[10], - 'ptable_offs' : raw_hdr[10] * self.sector_size, - 'ptable_size' : raw_hdr[11] * raw_hdr[12], - 'entries_cnt' : raw_hdr[11], - 'entry_size' : raw_hdr[12], - 'ptable_crc' : raw_hdr[13], - 'primary' : primary, - 'primary_str' : primary_str } - - def _read_raw_ptable(self, header): - """ Read and validate primary or backup partition table. The 'header' - argument is the GPT header. If it is the primary GPT header, then the - primary partition table is read and validated, otherwise - the backup - one. The 'header' argument is a dictionary which is returned by the - 'read_header()' method. """ - - raw_ptable = self._read_disk(header['ptable_offs'], - header['ptable_size']) - - crc = binascii.crc32(raw_ptable) & 0xFFFFFFFF - if crc != header['ptable_crc']: - raise MountError("Partition table at LBA %d (%s) is corrupted" % \ - (header['ptable_lba'], header['primary_str'])) - - return raw_ptable - - def get_partitions(self, primary = True): - """ This is a generator which parses the GPT partition table and - generates the following dictionary for each partition: - - 'index' : the index of the partition table endry - 'offs' : byte disk offset of the partition table entry - 'type_uuid' : partition type UUID - 'part_uuid' : partition UUID - 'first_lba' : the first LBA - 'last_lba' : the last LBA - 'flags' : attribute flags - 'name' : partition name - 'primary' : a boolean, if 'True', this is the primary partition - table, if 'False' - the secondary - 'primary_str' : contains string "primary" if this is the primary GPT - header, and "backup" otherwise - - This dictionary corresponds to the GPT header format. Please, see the - UEFI standard for the description of these fields. - - If the 'primary' parameter is 'True', partitions from the primary GPT - partition table are generated, otherwise partitions from the backup GPT - partition table are generated. """ - - if primary: - primary_str = "primary" - else: - primary_str = "backup" - - header = self.read_header(primary) - raw_ptable = self._read_raw_ptable(header) - - for index in xrange(0, header['entries_cnt']): - start = header['entry_size'] * index - end = start + header['entry_size'] - raw_entry = struct.unpack(_GPT_ENTRY_FORMAT, raw_ptable[start:end]) - - if raw_entry[2] == 0 or raw_entry[3] == 0: - continue - - part_name = str(raw_entry[5].decode('UTF-16').split('\0', 1)[0]) - - yield { 'index' : index, - 'offs' : header['ptable_offs'] + start, - 'type_uuid' : _stringify_uuid(raw_entry[0]), - 'part_uuid' : _stringify_uuid(raw_entry[1]), - 'first_lba' : raw_entry[2], - 'last_lba' : raw_entry[3], - 'flags' : raw_entry[4], - 'name' : part_name, - 'primary' : primary, - 'primary_str' : primary_str } - - def _change_partition(self, header, entry): - """ A helper function for 'change_partitions()' which changes a - a paricular instance of the partition table (primary or backup). """ - - if entry['index'] >= header['entries_cnt']: - raise MountError("Partition table at LBA %d has only %d " \ - "records cannot change record number %d" % \ - (header['entries_cnt'], entry['index'])) - # Read raw GPT header - raw_hdr = self._read_disk(header['hdr_offs'], _GPT_HEADER_SIZE) - raw_hdr = list(struct.unpack(_GPT_HEADER_FORMAT, raw_hdr)) - _validate_header(raw_hdr) - - # Prepare the new partition table entry - raw_entry = struct.pack(_GPT_ENTRY_FORMAT, - uuid.UUID(entry['type_uuid']).bytes_le, - uuid.UUID(entry['part_uuid']).bytes_le, - entry['first_lba'], - entry['last_lba'], - entry['flags'], - entry['name'].encode('UTF-16')) - - # Write the updated entry to the disk - entry_offs = header['ptable_offs'] + \ - header['entry_size'] * entry['index'] - self._write_disk(entry_offs, raw_entry) - - # Calculate and update partition table CRC32 - raw_ptable = self._read_disk(header['ptable_offs'], - header['ptable_size']) - raw_hdr[13] = binascii.crc32(raw_ptable) & 0xFFFFFFFF - - # Calculate and update the GPT header CRC - raw_hdr[3] = _calc_header_crc(raw_hdr) - - # Write the updated header to the disk - raw_hdr = struct.pack(_GPT_HEADER_FORMAT, *raw_hdr) - self._write_disk(header['hdr_offs'], raw_hdr) - - def change_partition(self, entry): - """ Change a GPT partition. The 'entry' argument has the same format as - 'get_partitions()' returns. This function simply changes the partition - table record corresponding to 'entry' in both, the primary and the - backup GPT partition tables. The parition table CRC is re-calculated - and the GPT headers are modified accordingly. """ - - # Change the primary partition table - header = self.read_header(True) - self._change_partition(header, entry) - - # Change the backup partition table - header = self.read_header(False) - self._change_partition(header, entry) diff --git a/scripts/lib/mic/utils/grabber.py b/scripts/lib/mic/utils/grabber.py deleted file mode 100644 index 45e30b4fb0..0000000000 --- a/scripts/lib/mic/utils/grabber.py +++ /dev/null @@ -1,97 +0,0 @@ -#!/usr/bin/python - -import os -import sys -import rpm -import fcntl -import struct -import termios - -from mic import msger -from mic.utils import runner -from mic.utils.errors import CreatorError - -from urlgrabber import grabber -from urlgrabber import __version__ as grabber_version - -if rpm.labelCompare(grabber_version.split('.'), '3.9.0'.split('.')) == -1: - msger.warning("Version of python-urlgrabber is %s, lower than '3.9.0', " - "you may encounter some network issues" % grabber_version) - -def myurlgrab(url, filename, proxies, progress_obj = None): - g = grabber.URLGrabber() - if progress_obj is None: - progress_obj = TextProgress() - - if url.startswith("file:/"): - filepath = "/%s" % url.replace("file:", "").lstrip('/') - if not os.path.exists(filepath): - raise CreatorError("URLGrabber error: can't find file %s" % url) - if url.endswith('.rpm'): - return filepath - else: - # untouch repometadata in source path - runner.show(['cp', '-f', filepath, filename]) - - else: - try: - filename = g.urlgrab(url=str(url), - filename=filename, - ssl_verify_host=False, - ssl_verify_peer=False, - proxies=proxies, - http_headers=(('Pragma', 'no-cache'),), - quote=0, - progress_obj=progress_obj) - except grabber.URLGrabError, err: - msg = str(err) - if msg.find(url) < 0: - msg += ' on %s' % url - raise CreatorError(msg) - - return filename - -def terminal_width(fd=1): - """ Get the real terminal width """ - try: - buf = 'abcdefgh' - buf = fcntl.ioctl(fd, termios.TIOCGWINSZ, buf) - return struct.unpack('hhhh', buf)[1] - except: # IOError - return 80 - -def truncate_url(url, width): - return os.path.basename(url)[0:width] - -class TextProgress(object): - # make the class as singleton - _instance = None - def __new__(cls, *args, **kwargs): - if not cls._instance: - cls._instance = super(TextProgress, cls).__new__(cls, *args, **kwargs) - - return cls._instance - - def __init__(self, totalnum = None): - self.total = totalnum - self.counter = 1 - - def start(self, filename, url, *args, **kwargs): - self.url = url - self.termwidth = terminal_width() - msger.info("\r%-*s" % (self.termwidth, " ")) - if self.total is None: - msger.info("\rRetrieving %s ..." % truncate_url(self.url, self.termwidth - 15)) - else: - msger.info("\rRetrieving %s [%d/%d] ..." % (truncate_url(self.url, self.termwidth - 25), self.counter, self.total)) - - def update(self, *args): - pass - - def end(self, *args): - if self.counter == self.total: - msger.raw("\n") - - if self.total is not None: - self.counter += 1 - diff --git a/scripts/lib/mic/utils/misc.py b/scripts/lib/mic/utils/misc.py deleted file mode 100644 index 95241d7f15..0000000000 --- a/scripts/lib/mic/utils/misc.py +++ /dev/null @@ -1,1065 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2010, 2011 Intel Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os -import sys -import time -import tempfile -import re -import shutil -import glob -import hashlib -import subprocess -import platform -import traceback - - -try: - import sqlite3 as sqlite -except ImportError: - import sqlite - -try: - from xml.etree import cElementTree -except ImportError: - import cElementTree -xmlparse = cElementTree.parse - -from mic import msger -from mic.utils.errors import CreatorError, SquashfsError -from mic.utils.fs_related import find_binary_path, makedirs -from mic.utils.proxy import get_proxy_for -from mic.utils import runner - - -RPM_RE = re.compile("(.*)\.(.*) (.*)-(.*)") -RPM_FMT = "%(name)s.%(arch)s %(version)s-%(release)s" -SRPM_RE = re.compile("(.*)-(\d+.*)-(\d+\.\d+).src.rpm") - - -def build_name(kscfg, release=None, prefix = None, suffix = None): - """Construct and return an image name string. - - This is a utility function to help create sensible name and fslabel - strings. The name is constructed using the sans-prefix-and-extension - kickstart filename and the supplied prefix and suffix. - - kscfg -- a path to a kickstart file - release -- a replacement to suffix for image release - prefix -- a prefix to prepend to the name; defaults to None, which causes - no prefix to be used - suffix -- a suffix to append to the name; defaults to None, which causes - a YYYYMMDDHHMM suffix to be used - - Note, if maxlen is less then the len(suffix), you get to keep both pieces. - - """ - name = os.path.basename(kscfg) - idx = name.rfind('.') - if idx >= 0: - name = name[:idx] - - if release is not None: - suffix = "" - if prefix is None: - prefix = "" - if suffix is None: - suffix = time.strftime("%Y%m%d%H%M") - - if name.startswith(prefix): - name = name[len(prefix):] - - prefix = "%s-" % prefix if prefix else "" - suffix = "-%s" % suffix if suffix else "" - - ret = prefix + name + suffix - return ret - -def get_distro(): - """Detect linux distribution, support "meego" - """ - - support_dists = ('SuSE', - 'debian', - 'fedora', - 'redhat', - 'centos', - 'meego', - 'moblin', - 'tizen') - try: - (dist, ver, id) = platform.linux_distribution( \ - supported_dists = support_dists) - except: - (dist, ver, id) = platform.dist( \ - supported_dists = support_dists) - - return (dist, ver, id) - -def get_distro_str(): - """Get composited string for current linux distribution - """ - (dist, ver, id) = get_distro() - - if not dist: - return 'Unknown Linux Distro' - else: - distro_str = ' '.join(map(str.strip, (dist, ver, id))) - return distro_str.strip() - -_LOOP_RULE_PTH = None - -def hide_loopdev_presentation(): - udev_rules = "80-prevent-loop-present.rules" - udev_rules_dir = [ - '/usr/lib/udev/rules.d/', - '/lib/udev/rules.d/', - '/etc/udev/rules.d/' - ] - - global _LOOP_RULE_PTH - - for rdir in udev_rules_dir: - if os.path.exists(rdir): - _LOOP_RULE_PTH = os.path.join(rdir, udev_rules) - - if not _LOOP_RULE_PTH: - return - - try: - with open(_LOOP_RULE_PTH, 'w') as wf: - wf.write('KERNEL=="loop*", ENV{UDISKS_PRESENTATION_HIDE}="1"') - - runner.quiet('udevadm trigger') - except: - pass - -def unhide_loopdev_presentation(): - global _LOOP_RULE_PTH - - if not _LOOP_RULE_PTH: - return - - try: - os.unlink(_LOOP_RULE_PTH) - runner.quiet('udevadm trigger') - except: - pass - -def extract_rpm(rpmfile, targetdir): - rpm2cpio = find_binary_path("rpm2cpio") - cpio = find_binary_path("cpio") - - olddir = os.getcwd() - os.chdir(targetdir) - - msger.verbose("Extract rpm file with cpio: %s" % rpmfile) - p1 = subprocess.Popen([rpm2cpio, rpmfile], stdout=subprocess.PIPE) - p2 = subprocess.Popen([cpio, "-idv"], stdin=p1.stdout, - stdout=subprocess.PIPE, stderr=subprocess.PIPE) - (sout, serr) = p2.communicate() - msger.verbose(sout or serr) - - os.chdir(olddir) - -def compressing(fpath, method): - comp_map = { - "gz": "gzip", - "bz2": "bzip2" - } - if method not in comp_map: - raise CreatorError("Unsupport compress format: %s, valid values: %s" - % (method, ','.join(comp_map.keys()))) - cmd = find_binary_path(comp_map[method]) - rc = runner.show([cmd, "-f", fpath]) - if rc: - raise CreatorError("Failed to %s file: %s" % (comp_map[method], fpath)) - -def taring(dstfile, target): - import tarfile - basen, ext = os.path.splitext(dstfile) - comp = {".tar": None, - ".gz": "gz", # for .tar.gz - ".bz2": "bz2", # for .tar.bz2 - ".tgz": "gz", - ".tbz": "bz2"}[ext] - - # specify tarball file path - if not comp: - tarpath = dstfile - elif basen.endswith(".tar"): - tarpath = basen - else: - tarpath = basen + ".tar" - wf = tarfile.open(tarpath, 'w') - - if os.path.isdir(target): - for item in os.listdir(target): - wf.add(os.path.join(target, item), item) - else: - wf.add(target, os.path.basename(target)) - wf.close() - - if comp: - compressing(tarpath, comp) - # when dstfile ext is ".tgz" and ".tbz", should rename - if not basen.endswith(".tar"): - shutil.move("%s.%s" % (tarpath, comp), dstfile) - -def ziping(dstfile, target): - import zipfile - wf = zipfile.ZipFile(dstfile, 'w', compression=zipfile.ZIP_DEFLATED) - if os.path.isdir(target): - for item in os.listdir(target): - fpath = os.path.join(target, item) - if not os.path.isfile(fpath): - continue - wf.write(fpath, item, zipfile.ZIP_DEFLATED) - else: - wf.write(target, os.path.basename(target), zipfile.ZIP_DEFLATED) - wf.close() - -pack_formats = { - ".tar": taring, - ".tar.gz": taring, - ".tar.bz2": taring, - ".tgz": taring, - ".tbz": taring, - ".zip": ziping, -} - -def packing(dstfile, target): - (base, ext) = os.path.splitext(dstfile) - if ext in (".gz", ".bz2") and base.endswith(".tar"): - ext = ".tar" + ext - if ext not in pack_formats: - raise CreatorError("Unsupport pack format: %s, valid values: %s" - % (ext, ','.join(pack_formats.keys()))) - func = pack_formats[ext] - # func should be callable - func(dstfile, target) - -def human_size(size): - """Return human readable string for Bytes size - """ - - if size <= 0: - return "0M" - import math - measure = ['B', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'] - expo = int(math.log(size, 1024)) - mant = float(size/math.pow(1024, expo)) - return "{0:.1f}{1:s}".format(mant, measure[expo]) - -def get_block_size(file_obj): - """ Returns block size for file object 'file_obj'. Errors are indicated by - the 'IOError' exception. """ - - from fcntl import ioctl - import struct - - # Get the block size of the host file-system for the image file by calling - # the FIGETBSZ ioctl (number 2). - binary_data = ioctl(file_obj, 2, struct.pack('I', 0)) - return struct.unpack('I', binary_data)[0] - -def check_space_pre_cp(src, dst): - """Check whether disk space is enough before 'cp' like - operations, else exception will be raised. - """ - - srcsize = get_file_size(src) * 1024 * 1024 - freesize = get_filesystem_avail(dst) - if srcsize > freesize: - raise CreatorError("space on %s(%s) is not enough for about %s files" - % (dst, human_size(freesize), human_size(srcsize))) - -def calc_hashes(file_path, hash_names, start = 0, end = None): - """ Calculate hashes for a file. The 'file_path' argument is the file - to calculate hash functions for, 'start' and 'end' are the starting and - ending file offset to calculate the has functions for. The 'hash_names' - argument is a list of hash names to calculate. Returns the the list - of calculated hash values in the hexadecimal form in the same order - as 'hash_names'. - """ - if end == None: - end = os.path.getsize(file_path) - - chunk_size = 65536 - to_read = end - start - read = 0 - - hashes = [] - for hash_name in hash_names: - hashes.append(hashlib.new(hash_name)) - - with open(file_path, "rb") as f: - f.seek(start) - - while read < to_read: - if read + chunk_size > to_read: - chunk_size = to_read - read - chunk = f.read(chunk_size) - for hash_obj in hashes: - hash_obj.update(chunk) - read += chunk_size - - result = [] - for hash_obj in hashes: - result.append(hash_obj.hexdigest()) - - return result - -def get_md5sum(fpath): - return calc_hashes(fpath, ('md5', ))[0] - - -def normalize_ksfile(ksconf, release, arch): - ''' - Return the name of a normalized ks file in which macro variables - @BUILD_ID@ and @ARCH@ are replace with real values. - - The original ks file is returned if no special macro is used, otherwise - a temp file is created and returned, which will be deleted when program - exits normally. - ''' - - if not release: - release = "latest" - if not arch or re.match(r'i.86', arch): - arch = "ia32" - - with open(ksconf) as f: - ksc = f.read() - - if "@ARCH@" not in ksc and "@BUILD_ID@" not in ksc: - return ksconf - - msger.info("Substitute macro variable @BUILD_ID@/@ARCH@ in ks: %s" % ksconf) - ksc = ksc.replace("@ARCH@", arch) - ksc = ksc.replace("@BUILD_ID@", release) - - fd, ksconf = tempfile.mkstemp(prefix=os.path.basename(ksconf)) - os.write(fd, ksc) - os.close(fd) - - msger.debug('normalized ks file:%s' % ksconf) - - def remove_temp_ks(): - try: - os.unlink(ksconf) - except OSError, err: - msger.warning('Failed to remove temp ks file:%s:%s' % (ksconf, err)) - - import atexit - atexit.register(remove_temp_ks) - - return ksconf - - -def _check_mic_chroot(rootdir): - def _path(path): - return rootdir.rstrip('/') + path - - release_files = map(_path, [ "/etc/moblin-release", - "/etc/meego-release", - "/etc/tizen-release"]) - - if not any(map(os.path.exists, release_files)): - msger.warning("Dir %s is not a MeeGo/Tizen chroot env" % rootdir) - - if not glob.glob(rootdir + "/boot/vmlinuz-*"): - msger.warning("Failed to find kernel module under %s" % rootdir) - - return - -def selinux_check(arch, fstypes): - try: - getenforce = find_binary_path('getenforce') - except CreatorError: - return - - selinux_status = runner.outs([getenforce]) - if arch and arch.startswith("arm") and selinux_status == "Enforcing": - raise CreatorError("Can't create arm image if selinux is enabled, " - "please run 'setenforce 0' to disable selinux") - - use_btrfs = filter(lambda typ: typ == 'btrfs', fstypes) - if use_btrfs and selinux_status == "Enforcing": - raise CreatorError("Can't create btrfs image if selinux is enabled," - " please run 'setenforce 0' to disable selinux") - -def get_image_type(path): - def _get_extension_name(path): - match = re.search("(?<=\.)\w+$", path) - if match: - return match.group(0) - else: - return None - - if os.path.isdir(path): - _check_mic_chroot(path) - return "fs" - - maptab = { - "tar": "loop", - "raw":"raw", - "vmdk":"vmdk", - "vdi":"vdi", - "iso":"livecd", - "usbimg":"liveusb", - } - - extension = _get_extension_name(path) - if extension in maptab: - return maptab[extension] - - fd = open(path, "rb") - file_header = fd.read(1024) - fd.close() - vdi_flag = "<<< Sun VirtualBox Disk Image >>>" - if file_header[0:len(vdi_flag)] == vdi_flag: - return maptab["vdi"] - - output = runner.outs(['file', path]) - isoptn = re.compile(r".*ISO 9660 CD-ROM filesystem.*(bootable).*") - usbimgptn = re.compile(r".*x86 boot sector.*active.*") - rawptn = re.compile(r".*x86 boot sector.*") - vmdkptn = re.compile(r".*VMware. disk image.*") - ext3fsimgptn = re.compile(r".*Linux.*ext3 filesystem data.*") - ext4fsimgptn = re.compile(r".*Linux.*ext4 filesystem data.*") - btrfsimgptn = re.compile(r".*BTRFS.*") - if isoptn.match(output): - return maptab["iso"] - elif usbimgptn.match(output): - return maptab["usbimg"] - elif rawptn.match(output): - return maptab["raw"] - elif vmdkptn.match(output): - return maptab["vmdk"] - elif ext3fsimgptn.match(output): - return "ext3fsimg" - elif ext4fsimgptn.match(output): - return "ext4fsimg" - elif btrfsimgptn.match(output): - return "btrfsimg" - else: - raise CreatorError("Cannot detect the type of image: %s" % path) - - -def get_file_size(filename): - """ Return size in MB unit """ - cmd = ['du', "-s", "-b", "-B", "1M", filename] - rc, duOutput = runner.runtool(cmd) - if rc != 0: - raise CreatorError("Failed to run: %s" % ' '.join(cmd)) - size1 = int(duOutput.split()[0]) - - cmd = ['du', "-s", "-B", "1M", filename] - rc, duOutput = runner.runtool(cmd) - if rc != 0: - raise CreatorError("Failed to run: %s" % ' '.join(cmd)) - - size2 = int(duOutput.split()[0]) - return max(size1, size2) - - -def get_filesystem_avail(fs): - vfstat = os.statvfs(fs) - return vfstat.f_bavail * vfstat.f_bsize - -def convert_image(srcimg, srcfmt, dstimg, dstfmt): - #convert disk format - if dstfmt != "raw": - raise CreatorError("Invalid destination image format: %s" % dstfmt) - msger.debug("converting %s image to %s" % (srcimg, dstimg)) - if srcfmt == "vmdk": - path = find_binary_path("qemu-img") - argv = [path, "convert", "-f", "vmdk", srcimg, "-O", dstfmt, dstimg] - elif srcfmt == "vdi": - path = find_binary_path("VBoxManage") - argv = [path, "internalcommands", "converttoraw", srcimg, dstimg] - else: - raise CreatorError("Invalid soure image format: %s" % srcfmt) - - rc = runner.show(argv) - if rc == 0: - msger.debug("convert successful") - if rc != 0: - raise CreatorError("Unable to convert disk to %s" % dstfmt) - -def uncompress_squashfs(squashfsimg, outdir): - """Uncompress file system from squshfs image""" - unsquashfs = find_binary_path("unsquashfs") - args = [ unsquashfs, "-d", outdir, squashfsimg ] - rc = runner.show(args) - if (rc != 0): - raise SquashfsError("Failed to uncompress %s." % squashfsimg) - -def mkdtemp(dir = "/var/tmp", prefix = "wic-tmp-"): - """ FIXME: use the dir in wic.conf instead """ - - makedirs(dir) - return tempfile.mkdtemp(dir = dir, prefix = prefix) - -def get_repostrs_from_ks(ks): - def _get_temp_reponame(baseurl): - md5obj = hashlib.md5(baseurl) - tmpreponame = "%s" % md5obj.hexdigest() - return tmpreponame - - kickstart_repos = [] - - for repodata in ks.handler.repo.repoList: - repo = {} - for attr in ('name', - 'baseurl', - 'mirrorlist', - 'includepkgs', # val is list - 'excludepkgs', # val is list - 'cost', # int - 'priority',# int - 'save', - 'proxy', - 'proxyuser', - 'proxypasswd', - 'proxypasswd', - 'debuginfo', - 'source', - 'gpgkey', - 'ssl_verify'): - if hasattr(repodata, attr) and getattr(repodata, attr): - repo[attr] = getattr(repodata, attr) - - if 'name' not in repo: - repo['name'] = _get_temp_reponame(repodata.baseurl) - - kickstart_repos.append(repo) - - return kickstart_repos - -def _get_uncompressed_data_from_url(url, filename, proxies): - filename = myurlgrab(url, filename, proxies) - suffix = None - if filename.endswith(".gz"): - suffix = ".gz" - runner.quiet(['gunzip', "-f", filename]) - elif filename.endswith(".bz2"): - suffix = ".bz2" - runner.quiet(['bunzip2', "-f", filename]) - if suffix: - filename = filename.replace(suffix, "") - return filename - -def _get_metadata_from_repo(baseurl, proxies, cachedir, reponame, filename, - sumtype=None, checksum=None): - url = os.path.join(baseurl, filename) - filename_tmp = str("%s/%s/%s" % (cachedir, reponame, os.path.basename(filename))) - if os.path.splitext(filename_tmp)[1] in (".gz", ".bz2"): - filename = os.path.splitext(filename_tmp)[0] - else: - filename = filename_tmp - if sumtype and checksum and os.path.exists(filename): - try: - sumcmd = find_binary_path("%ssum" % sumtype) - except: - file_checksum = None - else: - file_checksum = runner.outs([sumcmd, filename]).split()[0] - - if file_checksum and file_checksum == checksum: - return filename - - return _get_uncompressed_data_from_url(url,filename_tmp,proxies) - -def get_metadata_from_repos(repos, cachedir): - my_repo_metadata = [] - for repo in repos: - reponame = repo['name'] - baseurl = repo['baseurl'] - - - if 'proxy' in repo: - proxy = repo['proxy'] - else: - proxy = get_proxy_for(baseurl) - - proxies = None - if proxy: - proxies = {str(baseurl.split(":")[0]):str(proxy)} - - makedirs(os.path.join(cachedir, reponame)) - url = os.path.join(baseurl, "repodata/repomd.xml") - filename = os.path.join(cachedir, reponame, 'repomd.xml') - repomd = myurlgrab(url, filename, proxies) - try: - root = xmlparse(repomd) - except SyntaxError: - raise CreatorError("repomd.xml syntax error.") - - ns = root.getroot().tag - ns = ns[0:ns.rindex("}")+1] - - filepaths = {} - checksums = {} - sumtypes = {} - - for elm in root.getiterator("%sdata" % ns): - if elm.attrib["type"] == "patterns": - filepaths['patterns'] = elm.find("%slocation" % ns).attrib['href'] - checksums['patterns'] = elm.find("%sopen-checksum" % ns).text - sumtypes['patterns'] = elm.find("%sopen-checksum" % ns).attrib['type'] - break - - for elm in root.getiterator("%sdata" % ns): - if elm.attrib["type"] in ("group_gz", "group"): - filepaths['comps'] = elm.find("%slocation" % ns).attrib['href'] - checksums['comps'] = elm.find("%sopen-checksum" % ns).text - sumtypes['comps'] = elm.find("%sopen-checksum" % ns).attrib['type'] - break - - primary_type = None - for elm in root.getiterator("%sdata" % ns): - if elm.attrib["type"] in ("primary_db", "primary"): - primary_type = elm.attrib["type"] - filepaths['primary'] = elm.find("%slocation" % ns).attrib['href'] - checksums['primary'] = elm.find("%sopen-checksum" % ns).text - sumtypes['primary'] = elm.find("%sopen-checksum" % ns).attrib['type'] - break - - if not primary_type: - continue - - for item in ("primary", "patterns", "comps"): - if item not in filepaths: - filepaths[item] = None - continue - if not filepaths[item]: - continue - filepaths[item] = _get_metadata_from_repo(baseurl, - proxies, - cachedir, - reponame, - filepaths[item], - sumtypes[item], - checksums[item]) - - """ Get repo key """ - try: - repokey = _get_metadata_from_repo(baseurl, - proxies, - cachedir, - reponame, - "repodata/repomd.xml.key") - except CreatorError: - repokey = None - msger.debug("\ncan't get %s/%s" % (baseurl, "repodata/repomd.xml.key")) - - my_repo_metadata.append({"name":reponame, - "baseurl":baseurl, - "repomd":repomd, - "primary":filepaths['primary'], - "cachedir":cachedir, - "proxies":proxies, - "patterns":filepaths['patterns'], - "comps":filepaths['comps'], - "repokey":repokey}) - - return my_repo_metadata - -def get_rpmver_in_repo(repometadata): - for repo in repometadata: - if repo["primary"].endswith(".xml"): - root = xmlparse(repo["primary"]) - ns = root.getroot().tag - ns = ns[0:ns.rindex("}")+1] - - versionlist = [] - for elm in root.getiterator("%spackage" % ns): - if elm.find("%sname" % ns).text == 'rpm': - for node in elm.getchildren(): - if node.tag == "%sversion" % ns: - versionlist.append(node.attrib['ver']) - - if versionlist: - return reversed( - sorted( - versionlist, - key = lambda ver: map(int, ver.split('.')))).next() - - elif repo["primary"].endswith(".sqlite"): - con = sqlite.connect(repo["primary"]) - for row in con.execute("select version from packages where " - "name=\"rpm\" ORDER by version DESC"): - con.close() - return row[0] - - return None - -def get_arch(repometadata): - archlist = [] - for repo in repometadata: - if repo["primary"].endswith(".xml"): - root = xmlparse(repo["primary"]) - ns = root.getroot().tag - ns = ns[0:ns.rindex("}")+1] - for elm in root.getiterator("%spackage" % ns): - if elm.find("%sarch" % ns).text not in ("noarch", "src"): - arch = elm.find("%sarch" % ns).text - if arch not in archlist: - archlist.append(arch) - elif repo["primary"].endswith(".sqlite"): - con = sqlite.connect(repo["primary"]) - for row in con.execute("select arch from packages where arch not in (\"src\", \"noarch\")"): - if row[0] not in archlist: - archlist.append(row[0]) - - con.close() - - uniq_arch = [] - for i in range(len(archlist)): - if archlist[i] not in rpmmisc.archPolicies.keys(): - continue - need_append = True - j = 0 - while j < len(uniq_arch): - if archlist[i] in rpmmisc.archPolicies[uniq_arch[j]].split(':'): - need_append = False - break - if uniq_arch[j] in rpmmisc.archPolicies[archlist[i]].split(':'): - if need_append: - uniq_arch[j] = archlist[i] - need_append = False - else: - uniq_arch.remove(uniq_arch[j]) - continue - j += 1 - if need_append: - uniq_arch.append(archlist[i]) - - return uniq_arch, archlist - -def get_package(pkg, repometadata, arch = None): - ver = "" - target_repo = None - if not arch: - arches = [] - elif arch not in rpmmisc.archPolicies: - arches = [arch] - else: - arches = rpmmisc.archPolicies[arch].split(':') - arches.append('noarch') - - for repo in repometadata: - if repo["primary"].endswith(".xml"): - root = xmlparse(repo["primary"]) - ns = root.getroot().tag - ns = ns[0:ns.rindex("}")+1] - for elm in root.getiterator("%spackage" % ns): - if elm.find("%sname" % ns).text == pkg: - if elm.find("%sarch" % ns).text in arches: - version = elm.find("%sversion" % ns) - tmpver = "%s-%s" % (version.attrib['ver'], version.attrib['rel']) - if tmpver > ver: - ver = tmpver - location = elm.find("%slocation" % ns) - pkgpath = "%s" % location.attrib['href'] - target_repo = repo - break - if repo["primary"].endswith(".sqlite"): - con = sqlite.connect(repo["primary"]) - if arch: - sql = 'select version, release, location_href from packages ' \ - 'where name = "%s" and arch IN ("%s")' % \ - (pkg, '","'.join(arches)) - for row in con.execute(sql): - tmpver = "%s-%s" % (row[0], row[1]) - if tmpver > ver: - ver = tmpver - pkgpath = "%s" % row[2] - target_repo = repo - break - else: - sql = 'select version, release, location_href from packages ' \ - 'where name = "%s"' % pkg - for row in con.execute(sql): - tmpver = "%s-%s" % (row[0], row[1]) - if tmpver > ver: - ver = tmpver - pkgpath = "%s" % row[2] - target_repo = repo - break - con.close() - if target_repo: - makedirs("%s/packages/%s" % (target_repo["cachedir"], target_repo["name"])) - url = os.path.join(target_repo["baseurl"], pkgpath) - filename = str("%s/packages/%s/%s" % (target_repo["cachedir"], target_repo["name"], os.path.basename(pkgpath))) - if os.path.exists(filename): - ret = rpmmisc.checkRpmIntegrity('rpm', filename) - if ret == 0: - return filename - - msger.warning("package %s is damaged: %s" % - (os.path.basename(filename), filename)) - os.unlink(filename) - - pkg = myurlgrab(str(url), filename, target_repo["proxies"]) - return pkg - else: - return None - -def get_source_name(pkg, repometadata): - - def get_bin_name(pkg): - m = RPM_RE.match(pkg) - if m: - return m.group(1) - return None - - def get_src_name(srpm): - m = SRPM_RE.match(srpm) - if m: - return m.group(1) - return None - - ver = "" - target_repo = None - - pkg_name = get_bin_name(pkg) - if not pkg_name: - return None - - for repo in repometadata: - if repo["primary"].endswith(".xml"): - root = xmlparse(repo["primary"]) - ns = root.getroot().tag - ns = ns[0:ns.rindex("}")+1] - for elm in root.getiterator("%spackage" % ns): - if elm.find("%sname" % ns).text == pkg_name: - if elm.find("%sarch" % ns).text != "src": - version = elm.find("%sversion" % ns) - tmpver = "%s-%s" % (version.attrib['ver'], version.attrib['rel']) - if tmpver > ver: - ver = tmpver - fmt = elm.find("%sformat" % ns) - if fmt: - fns = fmt.getchildren()[0].tag - fns = fns[0:fns.rindex("}")+1] - pkgpath = fmt.find("%ssourcerpm" % fns).text - target_repo = repo - break - - if repo["primary"].endswith(".sqlite"): - con = sqlite.connect(repo["primary"]) - for row in con.execute("select version, release, rpm_sourcerpm from packages where name = \"%s\" and arch != \"src\"" % pkg_name): - tmpver = "%s-%s" % (row[0], row[1]) - if tmpver > ver: - pkgpath = "%s" % row[2] - target_repo = repo - break - con.close() - if target_repo: - return get_src_name(pkgpath) - else: - return None - -def get_pkglist_in_patterns(group, patterns): - found = False - pkglist = [] - try: - root = xmlparse(patterns) - except SyntaxError: - raise SyntaxError("%s syntax error." % patterns) - - for elm in list(root.getroot()): - ns = elm.tag - ns = ns[0:ns.rindex("}")+1] - name = elm.find("%sname" % ns) - summary = elm.find("%ssummary" % ns) - if name.text == group or summary.text == group: - found = True - break - - if not found: - return pkglist - - found = False - for requires in list(elm): - if requires.tag.endswith("requires"): - found = True - break - - if not found: - return pkglist - - for pkg in list(requires): - pkgname = pkg.attrib["name"] - if pkgname not in pkglist: - pkglist.append(pkgname) - - return pkglist - -def get_pkglist_in_comps(group, comps): - found = False - pkglist = [] - try: - root = xmlparse(comps) - except SyntaxError: - raise SyntaxError("%s syntax error." % comps) - - for elm in root.getiterator("group"): - id = elm.find("id") - name = elm.find("name") - if id.text == group or name.text == group: - packagelist = elm.find("packagelist") - found = True - break - - if not found: - return pkglist - - for require in elm.getiterator("packagereq"): - if require.tag.endswith("packagereq"): - pkgname = require.text - if pkgname not in pkglist: - pkglist.append(pkgname) - - return pkglist - -def is_statically_linked(binary): - return ", statically linked, " in runner.outs(['file', binary]) - -def setup_qemu_emulator(rootdir, arch): - # mount binfmt_misc if it doesn't exist - if not os.path.exists("/proc/sys/fs/binfmt_misc"): - modprobecmd = find_binary_path("modprobe") - runner.show([modprobecmd, "binfmt_misc"]) - if not os.path.exists("/proc/sys/fs/binfmt_misc/register"): - mountcmd = find_binary_path("mount") - runner.show([mountcmd, "-t", "binfmt_misc", "none", "/proc/sys/fs/binfmt_misc"]) - - # qemu_emulator is a special case, we can't use find_binary_path - # qemu emulator should be a statically-linked executable file - qemu_emulator = "/usr/bin/qemu-arm" - if not os.path.exists(qemu_emulator) or not is_statically_linked(qemu_emulator): - qemu_emulator = "/usr/bin/qemu-arm-static" - if not os.path.exists(qemu_emulator): - raise CreatorError("Please install a statically-linked qemu-arm") - - # qemu emulator version check - armv7_list = [arch for arch in rpmmisc.archPolicies.keys() if arch.startswith('armv7')] - if arch in armv7_list: # need qemu (>=0.13.0) - qemuout = runner.outs([qemu_emulator, "-h"]) - m = re.search("version\s*([.\d]+)", qemuout) - if m: - qemu_version = m.group(1) - if qemu_version < "0.13": - raise CreatorError("Requires %s version >=0.13 for %s" % (qemu_emulator, arch)) - else: - msger.warning("Can't get version info of %s, please make sure it's higher than 0.13.0" % qemu_emulator) - - if not os.path.exists(rootdir + "/usr/bin"): - makedirs(rootdir + "/usr/bin") - shutil.copy(qemu_emulator, rootdir + "/usr/bin/qemu-arm-static") - qemu_emulator = "/usr/bin/qemu-arm-static" - - # disable selinux, selinux will block qemu emulator to run - if os.path.exists("/usr/sbin/setenforce"): - msger.info('Try to disable selinux') - runner.show(["/usr/sbin/setenforce", "0"]) - - # unregister it if it has been registered and is a dynamically-linked executable - node = "/proc/sys/fs/binfmt_misc/arm" - if os.path.exists(node): - qemu_unregister_string = "-1\n" - fd = open("/proc/sys/fs/binfmt_misc/arm", "w") - fd.write(qemu_unregister_string) - fd.close() - - # register qemu emulator for interpreting other arch executable file - if not os.path.exists(node): - qemu_arm_string = ":arm:M::\\x7fELF\\x01\\x01\\x01\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x02\\x00\\x28\\x00:\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xfa\\xff\\xff\\xff:%s:\n" % qemu_emulator - fd = open("/proc/sys/fs/binfmt_misc/register", "w") - fd.write(qemu_arm_string) - fd.close() - - return qemu_emulator - -def SrcpkgsDownload(pkgs, repometadata, instroot, cachedir): - def get_source_repometadata(repometadata): - src_repometadata=[] - for repo in repometadata: - if repo["name"].endswith("-source"): - src_repometadata.append(repo) - if src_repometadata: - return src_repometadata - return None - - def get_src_name(srpm): - m = SRPM_RE.match(srpm) - if m: - return m.group(1) - return None - - src_repometadata = get_source_repometadata(repometadata) - - if not src_repometadata: - msger.warning("No source repo found") - return None - - src_pkgs = [] - lpkgs_dict = {} - lpkgs_path = [] - for repo in src_repometadata: - cachepath = "%s/%s/packages/*.src.rpm" %(cachedir, repo["name"]) - lpkgs_path += glob.glob(cachepath) - - for lpkg in lpkgs_path: - lpkg_name = get_src_name(os.path.basename(lpkg)) - lpkgs_dict[lpkg_name] = lpkg - localpkgs = lpkgs_dict.keys() - - cached_count = 0 - destdir = instroot+'/usr/src/SRPMS' - if not os.path.exists(destdir): - os.makedirs(destdir) - - srcpkgset = set() - for _pkg in pkgs: - srcpkg_name = get_source_name(_pkg, repometadata) - if not srcpkg_name: - continue - srcpkgset.add(srcpkg_name) - - for pkg in list(srcpkgset): - if pkg in localpkgs: - cached_count += 1 - shutil.copy(lpkgs_dict[pkg], destdir) - src_pkgs.append(os.path.basename(lpkgs_dict[pkg])) - else: - src_pkg = get_package(pkg, src_repometadata, 'src') - if src_pkg: - shutil.copy(src_pkg, destdir) - src_pkgs.append(src_pkg) - msger.info("%d source packages gotten from cache" % cached_count) - - return src_pkgs - -def strip_end(text, suffix): - if not text.endswith(suffix): - return text - return text[:-len(suffix)] diff --git a/scripts/lib/mic/utils/oe/__init__.py b/scripts/lib/mic/utils/oe/__init__.py deleted file mode 100644 index d10e802116..0000000000 --- a/scripts/lib/mic/utils/oe/__init__.py +++ /dev/null @@ -1,22 +0,0 @@ -# -# OpenEmbedded mic utils library -# -# Copyright (c) 2013, Intel Corporation. -# All rights reserved. -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License version 2 as -# published by the Free Software Foundation. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., -# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. -# -# AUTHORS -# Tom Zanussi <tom.zanussi (at] linux.intel.com> -# diff --git a/scripts/lib/mic/utils/oe/misc.py b/scripts/lib/mic/utils/oe/misc.py deleted file mode 100644 index 16c250aa9f..0000000000 --- a/scripts/lib/mic/utils/oe/misc.py +++ /dev/null @@ -1,174 +0,0 @@ -# ex:ts=4:sw=4:sts=4:et -# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- -# -# Copyright (c) 2013, Intel Corporation. -# All rights reserved. -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License version 2 as -# published by the Free Software Foundation. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., -# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. -# -# DESCRIPTION -# This module provides a place to collect various mic-related utils -# for the OpenEmbedded Image Tools. -# -# AUTHORS -# Tom Zanussi <tom.zanussi (at] linux.intel.com> -# - -from mic import msger -from mic.utils import runner - -def exec_cmd(cmd_and_args, as_shell = False, catch = 3): - """ - Execute command, catching stderr, stdout - - Need to execute as_shell if the command uses wildcards - """ - msger.debug("exec_cmd: %s" % cmd_and_args) - args = cmd_and_args.split() - msger.debug(args) - - if (as_shell): - rc, out = runner.runtool(cmd_and_args, catch) - else: - rc, out = runner.runtool(args, catch) - out = out.strip() - msger.debug("exec_cmd: output for %s (rc = %d): %s" % \ - (cmd_and_args, rc, out)) - - if rc != 0: - # We don't throw exception when return code is not 0, because - # parted always fails to reload part table with loop devices. This - # prevents us from distinguishing real errors based on return - # code. - msger.warning("WARNING: %s returned '%s' instead of 0" % (cmd_and_args, rc)) - - return (rc, out) - - -def exec_cmd_quiet(cmd_and_args, as_shell = False): - """ - Execute command, catching nothing in the output - - Need to execute as_shell if the command uses wildcards - """ - return exec_cmd(cmd_and_args, as_shell, 0) - - -def exec_native_cmd(cmd_and_args, native_sysroot, catch = 3): - """ - Execute native command, catching stderr, stdout - - Need to execute as_shell if the command uses wildcards - - Always need to execute native commands as_shell - """ - native_paths = \ - "export PATH=%s/sbin:%s/usr/sbin:%s/usr/bin:$PATH" % \ - (native_sysroot, native_sysroot, native_sysroot) - native_cmd_and_args = "%s;%s" % (native_paths, cmd_and_args) - msger.debug("exec_native_cmd: %s" % cmd_and_args) - - args = cmd_and_args.split() - msger.debug(args) - - rc, out = exec_cmd(native_cmd_and_args, True, catch) - - if rc == 127: # shell command-not-found - msger.error("A native (host) program required to build the image " - "was not found (see details above). Please make sure " - "it's installed and try again.") - - return (rc, out) - - -def exec_native_cmd_quiet(cmd_and_args, native_sysroot): - """ - Execute native command, catching nothing in the output - - Need to execute as_shell if the command uses wildcards - - Always need to execute native commands as_shell - """ - return exec_native_cmd(cmd_and_args, native_sysroot, 0) - - -# kickstart doesn't support variable substution in commands, so this -# is our current simplistic scheme for supporting that - -wks_vars = dict() - -def get_wks_var(key): - return wks_vars[key] - -def add_wks_var(key, val): - wks_vars[key] = val - -BOOTDD_EXTRA_SPACE = 16384 -IMAGE_EXTRA_SPACE = 10240 - -__bitbake_env_lines = "" - -def set_bitbake_env_lines(bitbake_env_lines): - global __bitbake_env_lines - __bitbake_env_lines = bitbake_env_lines - -def get_bitbake_env_lines(): - return __bitbake_env_lines - -def find_bitbake_env_lines(image_name): - """ - If image_name is empty, plugins might still be able to use the - environment, so set it regardless. - """ - if image_name: - bitbake_env_cmd = "bitbake -e %s" % image_name - else: - bitbake_env_cmd = "bitbake -e" - rc, bitbake_env_lines = exec_cmd(bitbake_env_cmd) - if rc != 0: - print "Couldn't get '%s' output." % bitbake_env_cmd - return None - - return bitbake_env_lines - -def find_artifact(bitbake_env_lines, variable): - """ - Gather the build artifact for the current image (the image_name - e.g. core-image-minimal) for the current MACHINE set in local.conf - """ - retval = "" - - for line in bitbake_env_lines.split('\n'): - if (get_line_val(line, variable)): - retval = get_line_val(line, variable) - break - - return retval - -def get_line_val(line, key): - """ - Extract the value from the VAR="val" string - """ - if line.startswith(key + "="): - stripped_line = line.split('=')[1] - stripped_line = stripped_line.replace('\"', '') - return stripped_line - return None - -def get_bitbake_var(key): - for line in __bitbake_env_lines.split('\n'): - if (get_line_val(line, key)): - val = get_line_val(line, key) - return val - return None diff --git a/scripts/lib/mic/utils/partitionedfs.py b/scripts/lib/mic/utils/partitionedfs.py deleted file mode 100644 index 593cf1f317..0000000000 --- a/scripts/lib/mic/utils/partitionedfs.py +++ /dev/null @@ -1,782 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2009, 2010, 2011 Intel, Inc. -# Copyright (c) 2007, 2008 Red Hat, Inc. -# Copyright (c) 2008 Daniel P. Berrange -# Copyright (c) 2008 David P. Huff -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os - -from mic import msger -from mic.utils import runner -from mic.utils.errors import MountError -from mic.utils.fs_related import * -from mic.utils.gpt_parser import GptParser -from mic.utils.oe.misc import * - -# Overhead of the MBR partitioning scheme (just one sector) -MBR_OVERHEAD = 1 -# Overhead of the GPT partitioning scheme -GPT_OVERHEAD = 34 - -# Size of a sector in bytes -SECTOR_SIZE = 512 - -class PartitionedMount(Mount): - def __init__(self, mountdir, skipformat = False): - Mount.__init__(self, mountdir) - self.disks = {} - self.partitions = [] - self.subvolumes = [] - self.mapped = False - self.mountOrder = [] - self.unmountOrder = [] - self.parted = find_binary_path("parted") - self.btrfscmd=None - self.skipformat = skipformat - self.snapshot_created = self.skipformat - # Size of a sector used in calculations - self.sector_size = SECTOR_SIZE - self._partitions_layed_out = False - - def __add_disk(self, disk_name): - """ Add a disk 'disk_name' to the internal list of disks. Note, - 'disk_name' is the name of the disk in the target system - (e.g., sdb). """ - - if disk_name in self.disks: - # We already have this disk - return - - assert not self._partitions_layed_out - - self.disks[disk_name] = \ - { 'disk': None, # Disk object - 'mapped': False, # True if kpartx mapping exists - 'numpart': 0, # Number of allocate partitions - 'partitions': [], # Indexes to self.partitions - 'offset': 0, # Offset of next partition (in sectors) - # Minimum required disk size to fit all partitions (in bytes) - 'min_size': 0, - 'ptable_format': "msdos" } # Partition table format - - def add_disk(self, disk_name, disk_obj): - """ Add a disk object which have to be partitioned. More than one disk - can be added. In case of multiple disks, disk partitions have to be - added for each disk separately with 'add_partition()". """ - - self.__add_disk(disk_name) - self.disks[disk_name]['disk'] = disk_obj - - def __add_partition(self, part): - """ This is a helper function for 'add_partition()' which adds a - partition to the internal list of partitions. """ - - assert not self._partitions_layed_out - - self.partitions.append(part) - self.__add_disk(part['disk_name']) - - def add_partition(self, size, disk_name, mountpoint, source_file = None, fstype = None, - label=None, fsopts = None, boot = False, align = None, - part_type = None): - """ Add the next partition. Prtitions have to be added in the - first-to-last order. """ - - ks_pnum = len(self.partitions) - - # Converting MB to sectors for parted - size = size * 1024 * 1024 / self.sector_size - - # We need to handle subvolumes for btrfs - if fstype == "btrfs" and fsopts and fsopts.find("subvol=") != -1: - self.btrfscmd=find_binary_path("btrfs") - subvol = None - opts = fsopts.split(",") - for opt in opts: - if opt.find("subvol=") != -1: - subvol = opt.replace("subvol=", "").strip() - break - if not subvol: - raise MountError("No subvolume: %s" % fsopts) - self.subvolumes.append({'size': size, # In sectors - 'mountpoint': mountpoint, # Mount relative to chroot - 'fstype': fstype, # Filesystem type - 'fsopts': fsopts, # Filesystem mount options - 'disk_name': disk_name, # physical disk name holding partition - 'device': None, # kpartx device node for partition - 'mount': None, # Mount object - 'subvol': subvol, # Subvolume name - 'boot': boot, # Bootable flag - 'mounted': False # Mount flag - }) - - # We still need partition for "/" or non-subvolume - if mountpoint == "/" or not fsopts or fsopts.find("subvol=") == -1: - # Don't need subvolume for "/" because it will be set as default subvolume - if fsopts and fsopts.find("subvol=") != -1: - opts = fsopts.split(",") - for opt in opts: - if opt.strip().startswith("subvol="): - opts.remove(opt) - break - fsopts = ",".join(opts) - - part = { 'ks_pnum' : ks_pnum, # Partition number in the KS file - 'size': size, # In sectors - 'mountpoint': mountpoint, # Mount relative to chroot - 'source_file': source_file, # partition contents - 'fstype': fstype, # Filesystem type - 'fsopts': fsopts, # Filesystem mount options - 'label': label, # Partition label - 'disk_name': disk_name, # physical disk name holding partition - 'device': None, # kpartx device node for partition - 'mount': None, # Mount object - 'num': None, # Partition number - 'boot': boot, # Bootable flag - 'align': align, # Partition alignment - 'part_type' : part_type, # Partition type - 'partuuid': None } # Partition UUID (GPT-only) - - self.__add_partition(part) - - def layout_partitions(self, ptable_format = "msdos"): - """ Layout the partitions, meaning calculate the position of every - partition on the disk. The 'ptable_format' parameter defines the - partition table format, and may be either "msdos" or "gpt". """ - - msger.debug("Assigning %s partitions to disks" % ptable_format) - - if ptable_format not in ('msdos', 'gpt'): - raise MountError("Unknown partition table format '%s', supported " \ - "formats are: 'msdos' and 'gpt'" % ptable_format) - - if self._partitions_layed_out: - return - - self._partitions_layed_out = True - - # Go through partitions in the order they are added in .ks file - for n in range(len(self.partitions)): - p = self.partitions[n] - - if not self.disks.has_key(p['disk_name']): - raise MountError("No disk %s for partition %s" \ - % (p['disk_name'], p['mountpoint'])) - - if p['part_type'] and ptable_format != 'gpt': - # The --part-type can also be implemented for MBR partitions, - # in which case it would map to the 1-byte "partition type" - # filed at offset 3 of the partition entry. - raise MountError("setting custom partition type is only " \ - "imlemented for GPT partitions") - - # Get the disk where the partition is located - d = self.disks[p['disk_name']] - d['numpart'] += 1 - d['ptable_format'] = ptable_format - - if d['numpart'] == 1: - if ptable_format == "msdos": - overhead = MBR_OVERHEAD - else: - overhead = GPT_OVERHEAD - - # Skip one sector required for the partitioning scheme overhead - d['offset'] += overhead - # Steal few sectors from the first partition to offset for the - # partitioning overhead - p['size'] -= overhead - - if p['align']: - # If not first partition and we do have alignment set we need - # to align the partition. - # FIXME: This leaves a empty spaces to the disk. To fill the - # gaps we could enlargea the previous partition? - - # Calc how much the alignment is off. - align_sectors = d['offset'] % (p['align'] * 1024 / self.sector_size) - # We need to move forward to the next alignment point - align_sectors = (p['align'] * 1024 / self.sector_size) - align_sectors - - msger.debug("Realignment for %s%s with %s sectors, original" - " offset %s, target alignment is %sK." % - (p['disk_name'], d['numpart'], align_sectors, - d['offset'], p['align'])) - - # increase the offset so we actually start the partition on right alignment - d['offset'] += align_sectors - - p['start'] = d['offset'] - d['offset'] += p['size'] - - p['type'] = 'primary' - p['num'] = d['numpart'] - - if d['ptable_format'] == "msdos": - if d['numpart'] > 2: - # Every logical partition requires an additional sector for - # the EBR, so steal the last sector from the end of each - # partition starting from the 3rd one for the EBR. This - # will make sure the logical partitions are aligned - # correctly. - p['size'] -= 1 - - if d['numpart'] > 3: - p['type'] = 'logical' - p['num'] = d['numpart'] + 1 - - d['partitions'].append(n) - msger.debug("Assigned %s to %s%d, sectors range %d-%d size %d " - "sectors (%d bytes)." \ - % (p['mountpoint'], p['disk_name'], p['num'], - p['start'], p['start'] + p['size'] - 1, - p['size'], p['size'] * self.sector_size)) - - # Once all the partitions have been layed out, we can calculate the - # minumim disk sizes. - for disk_name, d in self.disks.items(): - d['min_size'] = d['offset'] - if d['ptable_format'] == 'gpt': - # Account for the backup partition table at the end of the disk - d['min_size'] += GPT_OVERHEAD - - d['min_size'] *= self.sector_size - - def __run_parted(self, args): - """ Run parted with arguments specified in the 'args' list. """ - - args.insert(0, self.parted) - msger.debug(args) - - rc, out = runner.runtool(args, catch = 3) - out = out.strip() - if out: - msger.debug('"parted" output: %s' % out) - - if rc != 0: - # We don't throw exception when return code is not 0, because - # parted always fails to reload part table with loop devices. This - # prevents us from distinguishing real errors based on return - # code. - msger.error("WARNING: parted returned '%s' instead of 0 (use --debug for details)" % rc) - - def __create_partition(self, device, parttype, fstype, start, size): - """ Create a partition on an image described by the 'device' object. """ - - # Start is included to the size so we need to substract one from the end. - end = start + size - 1 - msger.debug("Added '%s' partition, sectors %d-%d, size %d sectors" % - (parttype, start, end, size)) - - args = ["-s", device, "unit", "s", "mkpart", parttype] - if fstype: - args.extend([fstype]) - args.extend(["%d" % start, "%d" % end]) - - return self.__run_parted(args) - - def __format_disks(self): - self.layout_partitions() - - if self.skipformat: - msger.debug("Skipping disk format, because skipformat flag is set.") - return - - for dev in self.disks.keys(): - d = self.disks[dev] - msger.debug("Initializing partition table for %s" % \ - (d['disk'].device)) - self.__run_parted(["-s", d['disk'].device, "mklabel", - d['ptable_format']]) - - msger.debug("Creating partitions") - - for p in self.partitions: - d = self.disks[p['disk_name']] - if d['ptable_format'] == "msdos" and p['num'] == 5: - # The last sector of the 3rd partition was reserved for the EBR - # of the first _logical_ partition. This is why the extended - # partition should start one sector before the first logical - # partition. - self.__create_partition(d['disk'].device, "extended", - None, p['start'] - 1, - d['offset'] - p['start']) - - if p['fstype'] == "swap": - parted_fs_type = "linux-swap" - elif p['fstype'] == "vfat": - parted_fs_type = "fat32" - elif p['fstype'] == "msdos": - parted_fs_type = "fat16" - else: - # Type for ext2/ext3/ext4/btrfs - parted_fs_type = "ext2" - - # Boot ROM of OMAP boards require vfat boot partition to have an - # even number of sectors. - if p['mountpoint'] == "/boot" and p['fstype'] in ["vfat", "msdos"] \ - and p['size'] % 2: - msger.debug("Substracting one sector from '%s' partition to " \ - "get even number of sectors for the partition" % \ - p['mountpoint']) - p['size'] -= 1 - - self.__create_partition(d['disk'].device, p['type'], - parted_fs_type, p['start'], p['size']) - - if p['boot']: - if d['ptable_format'] == 'gpt': - flag_name = "legacy_boot" - else: - flag_name = "boot" - msger.debug("Set '%s' flag for partition '%s' on disk '%s'" % \ - (flag_name, p['num'], d['disk'].device)) - self.__run_parted(["-s", d['disk'].device, "set", - "%d" % p['num'], flag_name, "on"]) - - # Parted defaults to enabling the lba flag for fat16 partitions, - # which causes compatibility issues with some firmware (and really - # isn't necessary). - if parted_fs_type == "fat16": - if d['ptable_format'] == 'msdos': - msger.debug("Disable 'lba' flag for partition '%s' on disk '%s'" % \ - (p['num'], d['disk'].device)) - self.__run_parted(["-s", d['disk'].device, "set", - "%d" % p['num'], "lba", "off"]) - - # If the partition table format is "gpt", find out PARTUUIDs for all - # the partitions. And if users specified custom parition type UUIDs, - # set them. - for disk_name, disk in self.disks.items(): - if disk['ptable_format'] != 'gpt': - continue - - pnum = 0 - gpt_parser = GptParser(d['disk'].device, SECTOR_SIZE) - # Iterate over all GPT partitions on this disk - for entry in gpt_parser.get_partitions(): - pnum += 1 - # Find the matching partition in the 'self.partitions' list - for n in d['partitions']: - p = self.partitions[n] - if p['num'] == pnum: - # Found, fetch PARTUUID (partition's unique ID) - p['partuuid'] = entry['part_uuid'] - msger.debug("PARTUUID for partition %d on disk '%s' " \ - "(mount point '%s') is '%s'" % (pnum, \ - disk_name, p['mountpoint'], p['partuuid'])) - if p['part_type']: - entry['type_uuid'] = p['part_type'] - msger.debug("Change type of partition %d on disk " \ - "'%s' (mount point '%s') to '%s'" % \ - (pnum, disk_name, p['mountpoint'], - p['part_type'])) - gpt_parser.change_partition(entry) - - del gpt_parser - - def __map_partitions(self): - """Load it if dm_snapshot isn't loaded. """ - load_module("dm_snapshot") - - for dev in self.disks.keys(): - d = self.disks[dev] - if d['mapped']: - continue - - msger.debug("Running kpartx on %s" % d['disk'].device ) - rc, kpartxOutput = runner.runtool([self.kpartx, "-l", "-v", d['disk'].device]) - kpartxOutput = kpartxOutput.splitlines() - - if rc != 0: - raise MountError("Failed to query partition mapping for '%s'" % - d['disk'].device) - - # Strip trailing blank and mask verbose output - i = 0 - while i < len(kpartxOutput) and kpartxOutput[i][0:4] != "loop": - i = i + 1 - kpartxOutput = kpartxOutput[i:] - - # Make sure kpartx reported the right count of partitions - if len(kpartxOutput) != d['numpart']: - # If this disk has more than 3 partitions, then in case of MBR - # paritions there is an extended parition. Different versions - # of kpartx behave differently WRT the extended partition - - # some map it, some ignore it. This is why we do the below hack - # - if kpartx reported one more partition and the partition - # table type is "msdos" and the amount of partitions is more - # than 3, we just assume kpartx mapped the extended parition - # and we remove it. - if len(kpartxOutput) == d['numpart'] + 1 \ - and d['ptable_format'] == 'msdos' and len(kpartxOutput) > 3: - kpartxOutput.pop(3) - else: - raise MountError("Unexpected number of partitions from " \ - "kpartx: %d != %d" % \ - (len(kpartxOutput), d['numpart'])) - - for i in range(len(kpartxOutput)): - line = kpartxOutput[i] - newdev = line.split()[0] - mapperdev = "/dev/mapper/" + newdev - loopdev = d['disk'].device + newdev[-1] - - msger.debug("Dev %s: %s -> %s" % (newdev, loopdev, mapperdev)) - pnum = d['partitions'][i] - self.partitions[pnum]['device'] = loopdev - - # grub's install wants partitions to be named - # to match their parent device + partition num - # kpartx doesn't work like this, so we add compat - # symlinks to point to /dev/mapper - if os.path.lexists(loopdev): - os.unlink(loopdev) - os.symlink(mapperdev, loopdev) - - msger.debug("Adding partx mapping for %s" % d['disk'].device) - rc = runner.show([self.kpartx, "-v", "-a", d['disk'].device]) - - if rc != 0: - # Make sure that the device maps are also removed on error case. - # The d['mapped'] isn't set to True if the kpartx fails so - # failed mapping will not be cleaned on cleanup either. - runner.quiet([self.kpartx, "-d", d['disk'].device]) - raise MountError("Failed to map partitions for '%s'" % - d['disk'].device) - - # FIXME: there is a bit delay for multipath device setup, - # wait 10ms for the setup - import time - time.sleep(10) - d['mapped'] = True - - def __unmap_partitions(self): - for dev in self.disks.keys(): - d = self.disks[dev] - if not d['mapped']: - continue - - msger.debug("Removing compat symlinks") - for pnum in d['partitions']: - if self.partitions[pnum]['device'] != None: - os.unlink(self.partitions[pnum]['device']) - self.partitions[pnum]['device'] = None - - msger.debug("Unmapping %s" % d['disk'].device) - rc = runner.quiet([self.kpartx, "-d", d['disk'].device]) - if rc != 0: - raise MountError("Failed to unmap partitions for '%s'" % - d['disk'].device) - - d['mapped'] = False - - def __calculate_mountorder(self): - msger.debug("Calculating mount order") - for p in self.partitions: - if p['mountpoint']: - self.mountOrder.append(p['mountpoint']) - self.unmountOrder.append(p['mountpoint']) - - self.mountOrder.sort() - self.unmountOrder.sort() - self.unmountOrder.reverse() - - def cleanup(self): - Mount.cleanup(self) - if self.disks: - self.__unmap_partitions() - for dev in self.disks.keys(): - d = self.disks[dev] - try: - d['disk'].cleanup() - except: - pass - - def unmount(self): - self.__unmount_subvolumes() - for mp in self.unmountOrder: - if mp == 'swap': - continue - p = None - for p1 in self.partitions: - if p1['mountpoint'] == mp: - p = p1 - break - - if p['mount'] != None: - try: - # Create subvolume snapshot here - if p['fstype'] == "btrfs" and p['mountpoint'] == "/" and not self.snapshot_created: - self.__create_subvolume_snapshots(p, p["mount"]) - p['mount'].cleanup() - except: - pass - p['mount'] = None - - # Only for btrfs - def __get_subvolume_id(self, rootpath, subvol): - if not self.btrfscmd: - self.btrfscmd=find_binary_path("btrfs") - argv = [ self.btrfscmd, "subvolume", "list", rootpath ] - - rc, out = runner.runtool(argv) - msger.debug(out) - - if rc != 0: - raise MountError("Failed to get subvolume id from %s', return code: %d." % (rootpath, rc)) - - subvolid = -1 - for line in out.splitlines(): - if line.endswith(" path %s" % subvol): - subvolid = line.split()[1] - if not subvolid.isdigit(): - raise MountError("Invalid subvolume id: %s" % subvolid) - subvolid = int(subvolid) - break - return subvolid - - def __create_subvolume_metadata(self, p, pdisk): - if len(self.subvolumes) == 0: - return - - argv = [ self.btrfscmd, "subvolume", "list", pdisk.mountdir ] - rc, out = runner.runtool(argv) - msger.debug(out) - - if rc != 0: - raise MountError("Failed to get subvolume id from %s', return code: %d." % (pdisk.mountdir, rc)) - - subvolid_items = out.splitlines() - subvolume_metadata = "" - for subvol in self.subvolumes: - for line in subvolid_items: - if line.endswith(" path %s" % subvol["subvol"]): - subvolid = line.split()[1] - if not subvolid.isdigit(): - raise MountError("Invalid subvolume id: %s" % subvolid) - - subvolid = int(subvolid) - opts = subvol["fsopts"].split(",") - for opt in opts: - if opt.strip().startswith("subvol="): - opts.remove(opt) - break - fsopts = ",".join(opts) - subvolume_metadata += "%d\t%s\t%s\t%s\n" % (subvolid, subvol["subvol"], subvol['mountpoint'], fsopts) - - if subvolume_metadata: - fd = open("%s/.subvolume_metadata" % pdisk.mountdir, "w") - fd.write(subvolume_metadata) - fd.close() - - def __get_subvolume_metadata(self, p, pdisk): - subvolume_metadata_file = "%s/.subvolume_metadata" % pdisk.mountdir - if not os.path.exists(subvolume_metadata_file): - return - - fd = open(subvolume_metadata_file, "r") - content = fd.read() - fd.close() - - for line in content.splitlines(): - items = line.split("\t") - if items and len(items) == 4: - self.subvolumes.append({'size': 0, # In sectors - 'mountpoint': items[2], # Mount relative to chroot - 'fstype': "btrfs", # Filesystem type - 'fsopts': items[3] + ",subvol=%s" % items[1], # Filesystem mount options - 'disk_name': p['disk_name'], # physical disk name holding partition - 'device': None, # kpartx device node for partition - 'mount': None, # Mount object - 'subvol': items[1], # Subvolume name - 'boot': False, # Bootable flag - 'mounted': False # Mount flag - }) - - def __create_subvolumes(self, p, pdisk): - """ Create all the subvolumes. """ - - for subvol in self.subvolumes: - argv = [ self.btrfscmd, "subvolume", "create", pdisk.mountdir + "/" + subvol["subvol"]] - - rc = runner.show(argv) - if rc != 0: - raise MountError("Failed to create subvolume '%s', return code: %d." % (subvol["subvol"], rc)) - - # Set default subvolume, subvolume for "/" is default - subvol = None - for subvolume in self.subvolumes: - if subvolume["mountpoint"] == "/" and p['disk_name'] == subvolume['disk_name']: - subvol = subvolume - break - - if subvol: - # Get default subvolume id - subvolid = self. __get_subvolume_id(pdisk.mountdir, subvol["subvol"]) - # Set default subvolume - if subvolid != -1: - rc = runner.show([ self.btrfscmd, "subvolume", "set-default", "%d" % subvolid, pdisk.mountdir]) - if rc != 0: - raise MountError("Failed to set default subvolume id: %d', return code: %d." % (subvolid, rc)) - - self.__create_subvolume_metadata(p, pdisk) - - def __mount_subvolumes(self, p, pdisk): - if self.skipformat: - # Get subvolume info - self.__get_subvolume_metadata(p, pdisk) - # Set default mount options - if len(self.subvolumes) != 0: - for subvol in self.subvolumes: - if subvol["mountpoint"] == p["mountpoint"] == "/": - opts = subvol["fsopts"].split(",") - for opt in opts: - if opt.strip().startswith("subvol="): - opts.remove(opt) - break - pdisk.fsopts = ",".join(opts) - break - - if len(self.subvolumes) == 0: - # Return directly if no subvolumes - return - - # Remount to make default subvolume mounted - rc = runner.show([self.umountcmd, pdisk.mountdir]) - if rc != 0: - raise MountError("Failed to umount %s" % pdisk.mountdir) - - rc = runner.show([self.mountcmd, "-o", pdisk.fsopts, pdisk.disk.device, pdisk.mountdir]) - if rc != 0: - raise MountError("Failed to umount %s" % pdisk.mountdir) - - for subvol in self.subvolumes: - if subvol["mountpoint"] == "/": - continue - subvolid = self. __get_subvolume_id(pdisk.mountdir, subvol["subvol"]) - if subvolid == -1: - msger.debug("WARNING: invalid subvolume %s" % subvol["subvol"]) - continue - # Replace subvolume name with subvolume ID - opts = subvol["fsopts"].split(",") - for opt in opts: - if opt.strip().startswith("subvol="): - opts.remove(opt) - break - - opts.extend(["subvolrootid=0", "subvol=%s" % subvol["subvol"]]) - fsopts = ",".join(opts) - subvol['fsopts'] = fsopts - mountpoint = self.mountdir + subvol['mountpoint'] - makedirs(mountpoint) - rc = runner.show([self.mountcmd, "-o", fsopts, pdisk.disk.device, mountpoint]) - if rc != 0: - raise MountError("Failed to mount subvolume %s to %s" % (subvol["subvol"], mountpoint)) - subvol["mounted"] = True - - def __unmount_subvolumes(self): - """ It may be called multiple times, so we need to chekc if it is still mounted. """ - for subvol in self.subvolumes: - if subvol["mountpoint"] == "/": - continue - if not subvol["mounted"]: - continue - mountpoint = self.mountdir + subvol['mountpoint'] - rc = runner.show([self.umountcmd, mountpoint]) - if rc != 0: - raise MountError("Failed to unmount subvolume %s from %s" % (subvol["subvol"], mountpoint)) - subvol["mounted"] = False - - def __create_subvolume_snapshots(self, p, pdisk): - import time - - if self.snapshot_created: - return - - # Remount with subvolid=0 - rc = runner.show([self.umountcmd, pdisk.mountdir]) - if rc != 0: - raise MountError("Failed to umount %s" % pdisk.mountdir) - if pdisk.fsopts: - mountopts = pdisk.fsopts + ",subvolid=0" - else: - mountopts = "subvolid=0" - rc = runner.show([self.mountcmd, "-o", mountopts, pdisk.disk.device, pdisk.mountdir]) - if rc != 0: - raise MountError("Failed to umount %s" % pdisk.mountdir) - - # Create all the subvolume snapshots - snapshotts = time.strftime("%Y%m%d-%H%M") - for subvol in self.subvolumes: - subvolpath = pdisk.mountdir + "/" + subvol["subvol"] - snapshotpath = subvolpath + "_%s-1" % snapshotts - rc = runner.show([ self.btrfscmd, "subvolume", "snapshot", subvolpath, snapshotpath ]) - if rc != 0: - raise MountError("Failed to create subvolume snapshot '%s' for '%s', return code: %d." % (snapshotpath, subvolpath, rc)) - - self.snapshot_created = True - - def __install_partition(self, num, source_file, start, size): - """ - Install source_file contents into a partition. - """ - if not source_file: # nothing to install - return - - # Start is included in the size so need to substract one from the end. - end = start + size - 1 - msger.debug("Installed %s in partition %d, sectors %d-%d, size %d sectors" % (source_file, num, start, end, size)) - - dd_cmd = "dd if=%s of=%s bs=%d seek=%d count=%d conv=notrunc" % \ - (source_file, self.image_file, self.sector_size, start, size) - rc, out = exec_cmd(dd_cmd) - - - def install(self, image_file): - msger.debug("Installing partitions") - - self.image_file = image_file - - for p in self.partitions: - d = self.disks[p['disk_name']] - if d['ptable_format'] == "msdos" and p['num'] == 5: - # The last sector of the 3rd partition was reserved for the EBR - # of the first _logical_ partition. This is why the extended - # partition should start one sector before the first logical - # partition. - self.__install_partition(p['num'], p['source_file'], - p['start'] - 1, - d['offset'] - p['start']) - - self.__install_partition(p['num'], p['source_file'], - p['start'], p['size']) - - def mount(self): - for dev in self.disks.keys(): - d = self.disks[dev] - d['disk'].create() - - self.__format_disks() - - self.__calculate_mountorder() - - return - - def resparse(self, size = None): - # Can't re-sparse a disk image - too hard - pass diff --git a/scripts/lib/mic/utils/proxy.py b/scripts/lib/mic/utils/proxy.py deleted file mode 100644 index 91451a2d01..0000000000 --- a/scripts/lib/mic/utils/proxy.py +++ /dev/null @@ -1,183 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2010, 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os -import urlparse - -_my_proxies = {} -_my_noproxy = None -_my_noproxy_list = [] - -def set_proxy_environ(): - global _my_noproxy, _my_proxies - if not _my_proxies: - return - for key in _my_proxies.keys(): - os.environ[key + "_proxy"] = _my_proxies[key] - if not _my_noproxy: - return - os.environ["no_proxy"] = _my_noproxy - -def unset_proxy_environ(): - for env in ('http_proxy', - 'https_proxy', - 'ftp_proxy', - 'all_proxy'): - if env in os.environ: - del os.environ[env] - - ENV=env.upper() - if ENV in os.environ: - del os.environ[ENV] - -def _set_proxies(proxy = None, no_proxy = None): - """Return a dictionary of scheme -> proxy server URL mappings. - """ - - global _my_noproxy, _my_proxies - _my_proxies = {} - _my_noproxy = None - proxies = [] - if proxy: - proxies.append(("http_proxy", proxy)) - if no_proxy: - proxies.append(("no_proxy", no_proxy)) - - # Get proxy settings from environment if not provided - if not proxy and not no_proxy: - proxies = os.environ.items() - - # Remove proxy env variables, urllib2 can't handle them correctly - unset_proxy_environ() - - for name, value in proxies: - name = name.lower() - if value and name[-6:] == '_proxy': - if name[0:2] != "no": - _my_proxies[name[:-6]] = value - else: - _my_noproxy = value - -def _ip_to_int(ip): - ipint=0 - shift=24 - for dec in ip.split("."): - ipint |= int(dec) << shift - shift -= 8 - return ipint - -def _int_to_ip(val): - ipaddr="" - shift=0 - for i in range(4): - dec = val >> shift - dec &= 0xff - ipaddr = ".%d%s" % (dec, ipaddr) - shift += 8 - return ipaddr[1:] - -def _isip(host): - if host.replace(".", "").isdigit(): - return True - return False - -def _set_noproxy_list(): - global _my_noproxy, _my_noproxy_list - _my_noproxy_list = [] - if not _my_noproxy: - return - for item in _my_noproxy.split(","): - item = item.strip() - if not item: - continue - - if item[0] != '.' and item.find("/") == -1: - # Need to match it - _my_noproxy_list.append({"match":0,"needle":item}) - - elif item[0] == '.': - # Need to match at tail - _my_noproxy_list.append({"match":1,"needle":item}) - - elif item.find("/") > 3: - # IP/MASK, need to match at head - needle = item[0:item.find("/")].strip() - ip = _ip_to_int(needle) - netmask = 0 - mask = item[item.find("/")+1:].strip() - - if mask.isdigit(): - netmask = int(mask) - netmask = ~((1<<(32-netmask)) - 1) - ip &= netmask - else: - shift=24 - netmask=0 - for dec in mask.split("."): - netmask |= int(dec) << shift - shift -= 8 - ip &= netmask - - _my_noproxy_list.append({"match":2,"needle":ip,"netmask":netmask}) - -def _isnoproxy(url): - (scheme, host, path, parm, query, frag) = urlparse.urlparse(url) - - if '@' in host: - user_pass, host = host.split('@', 1) - - if ':' in host: - host, port = host.split(':', 1) - - hostisip = _isip(host) - for item in _my_noproxy_list: - if hostisip and item["match"] <= 1: - continue - - if item["match"] == 2 and hostisip: - if (_ip_to_int(host) & item["netmask"]) == item["needle"]: - return True - - if item["match"] == 0: - if host == item["needle"]: - return True - - if item["match"] == 1: - if host.rfind(item["needle"]) > 0: - return True - - return False - -def set_proxies(proxy = None, no_proxy = None): - _set_proxies(proxy, no_proxy) - _set_noproxy_list() - set_proxy_environ() - -def get_proxy_for(url): - if url.startswith('file:') or _isnoproxy(url): - return None - - type = url[0:url.index(":")] - proxy = None - if _my_proxies.has_key(type): - proxy = _my_proxies[type] - elif _my_proxies.has_key("http"): - proxy = _my_proxies["http"] - else: - proxy = None - - return proxy diff --git a/scripts/lib/mic/utils/rpmmisc.py b/scripts/lib/mic/utils/rpmmisc.py deleted file mode 100644 index af15763e18..0000000000 --- a/scripts/lib/mic/utils/rpmmisc.py +++ /dev/null @@ -1,600 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2008, 2009, 2010, 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os -import sys -import re -import rpm - -from mic import msger -from mic.utils.errors import CreatorError -from mic.utils.proxy import get_proxy_for -from mic.utils import runner - - -class RPMInstallCallback: - """ Command line callback class for callbacks from the RPM library. - """ - - def __init__(self, ts, output=1): - self.output = output - self.callbackfilehandles = {} - self.total_actions = 0 - self.total_installed = 0 - self.installed_pkg_names = [] - self.total_removed = 0 - self.mark = "+" - self.marks = 40 - self.lastmsg = None - self.tsInfo = None # this needs to be set for anything else to work - self.ts = ts - self.filelog = False - self.logString = [] - self.headmsg = "Installing" - - def _dopkgtup(self, hdr): - tmpepoch = hdr['epoch'] - if tmpepoch is None: epoch = '0' - else: epoch = str(tmpepoch) - - return (hdr['name'], hdr['arch'], epoch, hdr['version'], hdr['release']) - - def _makeHandle(self, hdr): - handle = '%s:%s.%s-%s-%s' % (hdr['epoch'], hdr['name'], hdr['version'], - hdr['release'], hdr['arch']) - - return handle - - def _localprint(self, msg): - if self.output: - msger.info(msg) - - def _makefmt(self, percent, progress = True): - l = len(str(self.total_actions)) - size = "%s.%s" % (l, l) - fmt_done = "[%" + size + "s/%" + size + "s]" - done = fmt_done % (self.total_installed + self.total_removed, - self.total_actions) - marks = self.marks - (2 * l) - width = "%s.%s" % (marks, marks) - fmt_bar = "%-" + width + "s" - if progress: - bar = fmt_bar % (self.mark * int(marks * (percent / 100.0)), ) - fmt = "\r %-10.10s: %-20.20s " + bar + " " + done - else: - bar = fmt_bar % (self.mark * marks, ) - fmt = " %-10.10s: %-20.20s " + bar + " " + done - return fmt - - def _logPkgString(self, hdr): - """return nice representation of the package for the log""" - (n,a,e,v,r) = self._dopkgtup(hdr) - if e == '0': - pkg = '%s.%s %s-%s' % (n, a, v, r) - else: - pkg = '%s.%s %s:%s-%s' % (n, a, e, v, r) - - return pkg - - def callback(self, what, bytes, total, h, user): - if what == rpm.RPMCALLBACK_TRANS_START: - if bytes == 6: - self.total_actions = total - - elif what == rpm.RPMCALLBACK_TRANS_PROGRESS: - pass - - elif what == rpm.RPMCALLBACK_TRANS_STOP: - pass - - elif what == rpm.RPMCALLBACK_INST_OPEN_FILE: - self.lastmsg = None - hdr = None - if h is not None: - try: - hdr, rpmloc = h - except: - rpmloc = h - hdr = readRpmHeader(self.ts, h) - - handle = self._makeHandle(hdr) - fd = os.open(rpmloc, os.O_RDONLY) - self.callbackfilehandles[handle]=fd - if hdr['name'] not in self.installed_pkg_names: - self.installed_pkg_names.append(hdr['name']) - self.total_installed += 1 - return fd - else: - self._localprint("No header - huh?") - - elif what == rpm.RPMCALLBACK_INST_CLOSE_FILE: - hdr = None - if h is not None: - try: - hdr, rpmloc = h - except: - rpmloc = h - hdr = readRpmHeader(self.ts, h) - - handle = self._makeHandle(hdr) - os.close(self.callbackfilehandles[handle]) - fd = 0 - - # log stuff - #pkgtup = self._dopkgtup(hdr) - self.logString.append(self._logPkgString(hdr)) - - elif what == rpm.RPMCALLBACK_INST_PROGRESS: - if h is not None: - percent = (self.total_installed*100L)/self.total_actions - if total > 0: - try: - hdr, rpmloc = h - except: - rpmloc = h - - m = re.match("(.*)-(\d+.*)-(\d+\.\d+)\.(.+)\.rpm", os.path.basename(rpmloc)) - if m: - pkgname = m.group(1) - else: - pkgname = os.path.basename(rpmloc) - if self.output: - fmt = self._makefmt(percent) - msg = fmt % (self.headmsg, pkgname) - if msg != self.lastmsg: - self.lastmsg = msg - - msger.info(msg) - - if self.total_installed == self.total_actions: - msger.raw('') - msger.verbose('\n'.join(self.logString)) - - elif what == rpm.RPMCALLBACK_UNINST_START: - pass - - elif what == rpm.RPMCALLBACK_UNINST_PROGRESS: - pass - - elif what == rpm.RPMCALLBACK_UNINST_STOP: - self.total_removed += 1 - - elif what == rpm.RPMCALLBACK_REPACKAGE_START: - pass - - elif what == rpm.RPMCALLBACK_REPACKAGE_STOP: - pass - - elif what == rpm.RPMCALLBACK_REPACKAGE_PROGRESS: - pass - -def readRpmHeader(ts, filename): - """ Read an rpm header. """ - - fd = os.open(filename, os.O_RDONLY) - h = ts.hdrFromFdno(fd) - os.close(fd) - return h - -def splitFilename(filename): - """ Pass in a standard style rpm fullname - - Return a name, version, release, epoch, arch, e.g.:: - foo-1.0-1.i386.rpm returns foo, 1.0, 1, i386 - 1:bar-9-123a.ia64.rpm returns bar, 9, 123a, 1, ia64 - """ - - if filename[-4:] == '.rpm': - filename = filename[:-4] - - archIndex = filename.rfind('.') - arch = filename[archIndex+1:] - - relIndex = filename[:archIndex].rfind('-') - rel = filename[relIndex+1:archIndex] - - verIndex = filename[:relIndex].rfind('-') - ver = filename[verIndex+1:relIndex] - - epochIndex = filename.find(':') - if epochIndex == -1: - epoch = '' - else: - epoch = filename[:epochIndex] - - name = filename[epochIndex + 1:verIndex] - return name, ver, rel, epoch, arch - -def getCanonX86Arch(arch): - # - if arch == "i586": - f = open("/proc/cpuinfo", "r") - lines = f.readlines() - f.close() - for line in lines: - if line.startswith("model name") and line.find("Geode(TM)") != -1: - return "geode" - return arch - # only athlon vs i686 isn't handled with uname currently - if arch != "i686": - return arch - - # if we're i686 and AuthenticAMD, then we should be an athlon - f = open("/proc/cpuinfo", "r") - lines = f.readlines() - f.close() - for line in lines: - if line.startswith("vendor") and line.find("AuthenticAMD") != -1: - return "athlon" - # i686 doesn't guarantee cmov, but we depend on it - elif line.startswith("flags") and line.find("cmov") == -1: - return "i586" - - return arch - -def getCanonX86_64Arch(arch): - if arch != "x86_64": - return arch - - vendor = None - f = open("/proc/cpuinfo", "r") - lines = f.readlines() - f.close() - for line in lines: - if line.startswith("vendor_id"): - vendor = line.split(':')[1] - break - if vendor is None: - return arch - - if vendor.find("Authentic AMD") != -1 or vendor.find("AuthenticAMD") != -1: - return "amd64" - if vendor.find("GenuineIntel") != -1: - return "ia32e" - return arch - -def getCanonArch(): - arch = os.uname()[4] - - if (len(arch) == 4 and arch[0] == "i" and arch[2:4] == "86"): - return getCanonX86Arch(arch) - - if arch == "x86_64": - return getCanonX86_64Arch(arch) - - return arch - -# Copy from libsatsolver:poolarch.c, with cleanup -archPolicies = { - "x86_64": "x86_64:i686:i586:i486:i386", - "i686": "i686:i586:i486:i386", - "i586": "i586:i486:i386", - "ia64": "ia64:i686:i586:i486:i386", - "armv7tnhl": "armv7tnhl:armv7thl:armv7nhl:armv7hl", - "armv7thl": "armv7thl:armv7hl", - "armv7nhl": "armv7nhl:armv7hl", - "armv7hl": "armv7hl", - "armv7l": "armv7l:armv6l:armv5tejl:armv5tel:armv5l:armv4tl:armv4l:armv3l", - "armv6l": "armv6l:armv5tejl:armv5tel:armv5l:armv4tl:armv4l:armv3l", - "armv5tejl": "armv5tejl:armv5tel:armv5l:armv4tl:armv4l:armv3l", - "armv5tel": "armv5tel:armv5l:armv4tl:armv4l:armv3l", - "armv5l": "armv5l:armv4tl:armv4l:armv3l", -} - -# dict mapping arch -> ( multicompat, best personality, biarch personality ) -multilibArches = { - "x86_64": ( "athlon", "x86_64", "athlon" ), -} - -# from yumUtils.py -arches = { - # ia32 - "athlon": "i686", - "i686": "i586", - "geode": "i586", - "i586": "i486", - "i486": "i386", - "i386": "noarch", - - # amd64 - "x86_64": "athlon", - "amd64": "x86_64", - "ia32e": "x86_64", - - # arm - "armv7tnhl": "armv7nhl", - "armv7nhl": "armv7hl", - "armv7hl": "noarch", - "armv7l": "armv6l", - "armv6l": "armv5tejl", - "armv5tejl": "armv5tel", - "armv5tel": "noarch", - - #itanium - "ia64": "noarch", -} - -def isMultiLibArch(arch=None): - """returns true if arch is a multilib arch, false if not""" - if arch is None: - arch = getCanonArch() - - if not arches.has_key(arch): # or we could check if it is noarch - return False - - if multilibArches.has_key(arch): - return True - - if multilibArches.has_key(arches[arch]): - return True - - return False - -def getBaseArch(): - myarch = getCanonArch() - if not arches.has_key(myarch): - return myarch - - if isMultiLibArch(arch=myarch): - if multilibArches.has_key(myarch): - return myarch - else: - return arches[myarch] - - if arches.has_key(myarch): - basearch = myarch - value = arches[basearch] - while value != 'noarch': - basearch = value - value = arches[basearch] - - return basearch - -def checkRpmIntegrity(bin_rpm, package): - return runner.quiet([bin_rpm, "-K", "--nosignature", package]) - -def checkSig(ts, package): - """ Takes a transaction set and a package, check it's sigs, - return 0 if they are all fine - return 1 if the gpg key can't be found - return 2 if the header is in someway damaged - return 3 if the key is not trusted - return 4 if the pkg is not gpg or pgp signed - """ - - value = 0 - currentflags = ts.setVSFlags(0) - fdno = os.open(package, os.O_RDONLY) - try: - hdr = ts.hdrFromFdno(fdno) - - except rpm.error, e: - if str(e) == "public key not availaiable": - value = 1 - if str(e) == "public key not available": - value = 1 - if str(e) == "public key not trusted": - value = 3 - if str(e) == "error reading package header": - value = 2 - else: - error, siginfo = getSigInfo(hdr) - if error == 101: - os.close(fdno) - del hdr - value = 4 - else: - del hdr - - try: - os.close(fdno) - except OSError: - pass - - ts.setVSFlags(currentflags) # put things back like they were before - return value - -def getSigInfo(hdr): - """ checks signature from an hdr hand back signature information and/or - an error code - """ - - import locale - locale.setlocale(locale.LC_ALL, 'C') - - string = '%|DSAHEADER?{%{DSAHEADER:pgpsig}}:{%|RSAHEADER?{%{RSAHEADER:pgpsig}}:{%|SIGGPG?{%{SIGGPG:pgpsig}}:{%|SIGPGP?{%{SIGPGP:pgpsig}}:{(none)}|}|}|}|' - siginfo = hdr.sprintf(string) - if siginfo != '(none)': - error = 0 - sigtype, sigdate, sigid = siginfo.split(',') - else: - error = 101 - sigtype = 'MD5' - sigdate = 'None' - sigid = 'None' - - infotuple = (sigtype, sigdate, sigid) - return error, infotuple - -def checkRepositoryEULA(name, repo): - """ This function is to check the EULA file if provided. - return True: no EULA or accepted - return False: user declined the EULA - """ - - import tempfile - import shutil - import urlparse - import urllib2 as u2 - import httplib - from mic.utils.errors import CreatorError - - def _check_and_download_url(u2opener, url, savepath): - try: - if u2opener: - f = u2opener.open(url) - else: - f = u2.urlopen(url) - except u2.HTTPError, httperror: - if httperror.code in (404, 503): - return None - else: - raise CreatorError(httperror) - except OSError, oserr: - if oserr.errno == 2: - return None - else: - raise CreatorError(oserr) - except IOError, oserr: - if hasattr(oserr, "reason") and oserr.reason.errno == 2: - return None - else: - raise CreatorError(oserr) - except u2.URLError, err: - raise CreatorError(err) - except httplib.HTTPException, e: - raise CreatorError(e) - - # save to file - licf = open(savepath, "w") - licf.write(f.read()) - licf.close() - f.close() - - return savepath - - def _pager_file(savepath): - - if os.path.splitext(savepath)[1].upper() in ('.HTM', '.HTML'): - pagers = ('w3m', 'links', 'lynx', 'less', 'more') - else: - pagers = ('less', 'more') - - file_showed = False - for pager in pagers: - cmd = "%s %s" % (pager, savepath) - try: - os.system(cmd) - except OSError: - continue - else: - file_showed = True - break - - if not file_showed: - f = open(savepath) - msger.raw(f.read()) - f.close() - msger.pause() - - # when proxy needed, make urllib2 follow it - proxy = repo.proxy - proxy_username = repo.proxy_username - proxy_password = repo.proxy_password - - if not proxy: - proxy = get_proxy_for(repo.baseurl[0]) - - handlers = [] - auth_handler = u2.HTTPBasicAuthHandler(u2.HTTPPasswordMgrWithDefaultRealm()) - u2opener = None - if proxy: - if proxy_username: - proxy_netloc = urlparse.urlsplit(proxy).netloc - if proxy_password: - proxy_url = 'http://%s:%s@%s' % (proxy_username, proxy_password, proxy_netloc) - else: - proxy_url = 'http://%s@%s' % (proxy_username, proxy_netloc) - else: - proxy_url = proxy - - proxy_support = u2.ProxyHandler({'http': proxy_url, - 'https': proxy_url, - 'ftp': proxy_url}) - handlers.append(proxy_support) - - # download all remote files to one temp dir - baseurl = None - repo_lic_dir = tempfile.mkdtemp(prefix = 'repolic') - - for url in repo.baseurl: - tmphandlers = handlers[:] - - (scheme, host, path, parm, query, frag) = urlparse.urlparse(url.rstrip('/') + '/') - if scheme not in ("http", "https", "ftp", "ftps", "file"): - raise CreatorError("Error: invalid url %s" % url) - - if '@' in host: - try: - user_pass, host = host.split('@', 1) - if ':' in user_pass: - user, password = user_pass.split(':', 1) - except ValueError, e: - raise CreatorError('Bad URL: %s' % url) - - msger.verbose("adding HTTP auth: %s, XXXXXXXX" %(user)) - auth_handler.add_password(None, host, user, password) - tmphandlers.append(auth_handler) - url = scheme + "://" + host + path + parm + query + frag - - if tmphandlers: - u2opener = u2.build_opener(*tmphandlers) - - # try to download - repo_eula_url = urlparse.urljoin(url, "LICENSE.txt") - repo_eula_path = _check_and_download_url( - u2opener, - repo_eula_url, - os.path.join(repo_lic_dir, repo.id + '_LICENSE.txt')) - if repo_eula_path: - # found - baseurl = url - break - - if not baseurl: - shutil.rmtree(repo_lic_dir) #cleanup - return True - - # show the license file - msger.info('For the software packages in this yum repo:') - msger.info(' %s: %s' % (name, baseurl)) - msger.info('There is an "End User License Agreement" file that need to be checked.') - msger.info('Please read the terms and conditions outlined in it and answer the followed qustions.') - msger.pause() - - _pager_file(repo_eula_path) - - # Asking for the "Accept/Decline" - if not msger.ask('Would you agree to the terms and conditions outlined in the above End User License Agreement?'): - msger.warning('Will not install pkgs from this repo.') - shutil.rmtree(repo_lic_dir) #cleanup - return False - - # try to find support_info.html for extra infomation - repo_info_url = urlparse.urljoin(baseurl, "support_info.html") - repo_info_path = _check_and_download_url( - u2opener, - repo_info_url, - os.path.join(repo_lic_dir, repo.id + '_support_info.html')) - if repo_info_path: - msger.info('There is one more file in the repo for additional support information, please read it') - msger.pause() - _pager_file(repo_info_path) - - #cleanup - shutil.rmtree(repo_lic_dir) - return True diff --git a/scripts/lib/mic/utils/runner.py b/scripts/lib/mic/utils/runner.py deleted file mode 100644 index fded3c93fa..0000000000 --- a/scripts/lib/mic/utils/runner.py +++ /dev/null @@ -1,109 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, Inc. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the Free -# Software Foundation; version 2 of the License -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os -import subprocess - -from mic import msger - -def runtool(cmdln_or_args, catch=1): - """ wrapper for most of the subprocess calls - input: - cmdln_or_args: can be both args and cmdln str (shell=True) - catch: 0, quitely run - 1, only STDOUT - 2, only STDERR - 3, both STDOUT and STDERR - return: - (rc, output) - if catch==0: the output will always None - """ - - if catch not in (0, 1, 2, 3): - # invalid catch selection, will cause exception, that's good - return None - - if isinstance(cmdln_or_args, list): - cmd = cmdln_or_args[0] - shell = False - else: - import shlex - cmd = shlex.split(cmdln_or_args)[0] - shell = True - - if catch != 3: - dev_null = os.open("/dev/null", os.O_WRONLY) - - if catch == 0: - sout = dev_null - serr = dev_null - elif catch == 1: - sout = subprocess.PIPE - serr = dev_null - elif catch == 2: - sout = dev_null - serr = subprocess.PIPE - elif catch == 3: - sout = subprocess.PIPE - serr = subprocess.STDOUT - - try: - p = subprocess.Popen(cmdln_or_args, stdout=sout, - stderr=serr, shell=shell) - (sout, serr) = p.communicate() - # combine stdout and stderr, filter None out - out = ''.join(filter(None, [sout, serr])) - except OSError, e: - if e.errno == 2: - # [Errno 2] No such file or directory - msger.error('Cannot run command: %s, lost dependency?' % cmd) - else: - raise # relay - finally: - if catch != 3: - os.close(dev_null) - - return (p.returncode, out) - -def show(cmdln_or_args): - # show all the message using msger.verbose - - rc, out = runtool(cmdln_or_args, catch=3) - - if isinstance(cmdln_or_args, list): - cmd = ' '.join(cmdln_or_args) - else: - cmd = cmdln_or_args - - msg = 'running command: "%s"' % cmd - if out: out = out.strip() - if out: - msg += ', with output::' - msg += '\n +----------------' - for line in out.splitlines(): - msg += '\n | %s' % line - msg += '\n +----------------' - - msger.verbose(msg) - return rc - -def outs(cmdln_or_args, catch=1): - # get the outputs of tools - return runtool(cmdln_or_args, catch)[1].strip() - -def quiet(cmdln_or_args): - return runtool(cmdln_or_args, catch=0)[0] diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/__init__.py b/scripts/lib/recipetool/__init__.py index e69de29bb2..e69de29bb2 100644 --- a/scripts/lib/mic/3rdparty/pykickstart/handlers/__init__.py +++ b/scripts/lib/recipetool/__init__.py diff --git a/scripts/lib/recipetool/append.py b/scripts/lib/recipetool/append.py new file mode 100644 index 0000000000..69c8bb77a0 --- /dev/null +++ b/scripts/lib/recipetool/append.py @@ -0,0 +1,457 @@ +# Recipe creation tool - append plugin +# +# Copyright (C) 2015 Intel Corporation +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +import sys +import os +import argparse +import glob +import fnmatch +import re +import subprocess +import logging +import stat +import shutil +import scriptutils +import errno +from collections import defaultdict + +logger = logging.getLogger('recipetool') + +tinfoil = None + +def tinfoil_init(instance): + global tinfoil + tinfoil = instance + + +# FIXME guessing when we don't have pkgdata? +# FIXME mode to create patch rather than directly substitute + +class InvalidTargetFileError(Exception): + pass + +def find_target_file(targetpath, d, pkglist=None): + """Find the recipe installing the specified target path, optionally limited to a select list of packages""" + import json + + pkgdata_dir = d.getVar('PKGDATA_DIR') + + # The mix between /etc and ${sysconfdir} here may look odd, but it is just + # being consistent with usage elsewhere + invalidtargets = {'${sysconfdir}/version': '${sysconfdir}/version is written out at image creation time', + '/etc/timestamp': '/etc/timestamp is written out at image creation time', + '/dev/*': '/dev is handled by udev (or equivalent) and the kernel (devtmpfs)', + '/etc/passwd': '/etc/passwd should be managed through the useradd and extrausers classes', + '/etc/group': '/etc/group should be managed through the useradd and extrausers classes', + '/etc/shadow': '/etc/shadow should be managed through the useradd and extrausers classes', + '/etc/gshadow': '/etc/gshadow should be managed through the useradd and extrausers classes', + '${sysconfdir}/hostname': '${sysconfdir}/hostname contents should be set by setting hostname_pn-base-files = "value" in configuration',} + + for pthspec, message in invalidtargets.items(): + if fnmatch.fnmatchcase(targetpath, d.expand(pthspec)): + raise InvalidTargetFileError(d.expand(message)) + + targetpath_re = re.compile(r'\s+(\$D)?%s(\s|$)' % targetpath) + + recipes = defaultdict(list) + for root, dirs, files in os.walk(os.path.join(pkgdata_dir, 'runtime')): + if pkglist: + filelist = pkglist + else: + filelist = files + for fn in filelist: + pkgdatafile = os.path.join(root, fn) + if pkglist and not os.path.exists(pkgdatafile): + continue + with open(pkgdatafile, 'r') as f: + pn = '' + # This does assume that PN comes before other values, but that's a fairly safe assumption + for line in f: + if line.startswith('PN:'): + pn = line.split(':', 1)[1].strip() + elif line.startswith('FILES_INFO:'): + val = line.split(':', 1)[1].strip() + dictval = json.loads(val) + for fullpth in dictval.keys(): + if fnmatch.fnmatchcase(fullpth, targetpath): + recipes[targetpath].append(pn) + elif line.startswith('pkg_preinst_') or line.startswith('pkg_postinst_'): + scriptval = line.split(':', 1)[1].strip().encode('utf-8').decode('unicode_escape') + if 'update-alternatives --install %s ' % targetpath in scriptval: + recipes[targetpath].append('?%s' % pn) + elif targetpath_re.search(scriptval): + recipes[targetpath].append('!%s' % pn) + return recipes + +def _parse_recipe(pn, tinfoil): + try: + rd = tinfoil.parse_recipe(pn) + except bb.providers.NoProvider as e: + logger.error(str(e)) + return None + return rd + +def determine_file_source(targetpath, rd): + """Assuming we know a file came from a specific recipe, figure out exactly where it came from""" + import oe.recipeutils + + # See if it's in do_install for the recipe + workdir = rd.getVar('WORKDIR') + src_uri = rd.getVar('SRC_URI') + srcfile = '' + modpatches = [] + elements = check_do_install(rd, targetpath) + if elements: + logger.debug('do_install line:\n%s' % ' '.join(elements)) + srcpath = get_source_path(elements) + logger.debug('source path: %s' % srcpath) + if not srcpath.startswith('/'): + # Handle non-absolute path + srcpath = os.path.abspath(os.path.join(rd.getVarFlag('do_install', 'dirs').split()[-1], srcpath)) + if srcpath.startswith(workdir): + # OK, now we have the source file name, look for it in SRC_URI + workdirfile = os.path.relpath(srcpath, workdir) + # FIXME this is where we ought to have some code in the fetcher, because this is naive + for item in src_uri.split(): + localpath = bb.fetch2.localpath(item, rd) + # Source path specified in do_install might be a glob + if fnmatch.fnmatch(os.path.basename(localpath), workdirfile): + srcfile = 'file://%s' % localpath + elif '/' in workdirfile: + if item == 'file://%s' % workdirfile: + srcfile = 'file://%s' % localpath + + # Check patches + srcpatches = [] + patchedfiles = oe.recipeutils.get_recipe_patched_files(rd) + for patch, filelist in patchedfiles.items(): + for fileitem in filelist: + if fileitem[0] == srcpath: + srcpatches.append((patch, fileitem[1])) + if srcpatches: + addpatch = None + for patch in srcpatches: + if patch[1] == 'A': + addpatch = patch[0] + else: + modpatches.append(patch[0]) + if addpatch: + srcfile = 'patch://%s' % addpatch + + return (srcfile, elements, modpatches) + +def get_source_path(cmdelements): + """Find the source path specified within a command""" + command = cmdelements[0] + if command in ['install', 'cp']: + helptext = subprocess.check_output('LC_ALL=C %s --help' % command, shell=True).decode('utf-8') + argopts = '' + argopt_line_re = re.compile('^-([a-zA-Z0-9]), --[a-z-]+=') + for line in helptext.splitlines(): + line = line.lstrip() + res = argopt_line_re.search(line) + if res: + argopts += res.group(1) + if not argopts: + # Fallback + if command == 'install': + argopts = 'gmoSt' + elif command == 'cp': + argopts = 't' + else: + raise Exception('No fallback arguments for command %s' % command) + + skipnext = False + for elem in cmdelements[1:-1]: + if elem.startswith('-'): + if len(elem) > 1 and elem[1] in argopts: + skipnext = True + continue + if skipnext: + skipnext = False + continue + return elem + else: + raise Exception('get_source_path: no handling for command "%s"') + +def get_func_deps(func, d): + """Find the function dependencies of a shell function""" + deps = bb.codeparser.ShellParser(func, logger).parse_shell(d.getVar(func)) + deps |= set((d.getVarFlag(func, "vardeps") or "").split()) + funcdeps = [] + for dep in deps: + if d.getVarFlag(dep, 'func'): + funcdeps.append(dep) + return funcdeps + +def check_do_install(rd, targetpath): + """Look at do_install for a command that installs/copies the specified target path""" + instpath = os.path.abspath(os.path.join(rd.getVar('D'), targetpath.lstrip('/'))) + do_install = rd.getVar('do_install') + # Handle where do_install calls other functions (somewhat crudely, but good enough for this purpose) + deps = get_func_deps('do_install', rd) + for dep in deps: + do_install = do_install.replace(dep, rd.getVar(dep)) + + # Look backwards through do_install as we want to catch where a later line (perhaps + # from a bbappend) is writing over the top + for line in reversed(do_install.splitlines()): + line = line.strip() + if (line.startswith('install ') and ' -m' in line) or line.startswith('cp '): + elements = line.split() + destpath = os.path.abspath(elements[-1]) + if destpath == instpath: + return elements + elif destpath.rstrip('/') == os.path.dirname(instpath): + # FIXME this doesn't take recursive copy into account; unsure if it's practical to do so + srcpath = get_source_path(elements) + if fnmatch.fnmatchcase(os.path.basename(instpath), os.path.basename(srcpath)): + return elements + return None + + +def appendfile(args): + import oe.recipeutils + + stdout = '' + try: + (stdout, _) = bb.process.run('LANG=C file -b %s' % args.newfile, shell=True) + if 'cannot open' in stdout: + raise bb.process.ExecutionError(stdout) + except bb.process.ExecutionError as err: + logger.debug('file command returned error: %s' % err) + stdout = '' + if stdout: + logger.debug('file command output: %s' % stdout.rstrip()) + if ('executable' in stdout and not 'shell script' in stdout) or 'shared object' in stdout: + logger.warn('This file looks like it is a binary or otherwise the output of compilation. If it is, you should consider building it properly instead of substituting a binary file directly.') + + if args.recipe: + recipes = {args.targetpath: [args.recipe],} + else: + try: + recipes = find_target_file(args.targetpath, tinfoil.config_data) + except InvalidTargetFileError as e: + logger.error('%s cannot be handled by this tool: %s' % (args.targetpath, e)) + return 1 + if not recipes: + logger.error('Unable to find any package producing path %s - this may be because the recipe packaging it has not been built yet' % args.targetpath) + return 1 + + alternative_pns = [] + postinst_pns = [] + + selectpn = None + for targetpath, pnlist in recipes.items(): + for pn in pnlist: + if pn.startswith('?'): + alternative_pns.append(pn[1:]) + elif pn.startswith('!'): + postinst_pns.append(pn[1:]) + elif selectpn: + # hit here with multilibs + continue + else: + selectpn = pn + + if not selectpn and len(alternative_pns) == 1: + selectpn = alternative_pns[0] + logger.error('File %s is an alternative possibly provided by recipe %s but seemingly no other, selecting it by default - you should double check other recipes' % (args.targetpath, selectpn)) + + if selectpn: + logger.debug('Selecting recipe %s for file %s' % (selectpn, args.targetpath)) + if postinst_pns: + logger.warn('%s be modified by postinstall scripts for the following recipes:\n %s\nThis may or may not be an issue depending on what modifications these postinstall scripts make.' % (args.targetpath, '\n '.join(postinst_pns))) + rd = _parse_recipe(selectpn, tinfoil) + if not rd: + # Error message already shown + return 1 + sourcefile, instelements, modpatches = determine_file_source(args.targetpath, rd) + sourcepath = None + if sourcefile: + sourcetype, sourcepath = sourcefile.split('://', 1) + logger.debug('Original source file is %s (%s)' % (sourcepath, sourcetype)) + if sourcetype == 'patch': + logger.warn('File %s is added by the patch %s - you may need to remove or replace this patch in order to replace the file.' % (args.targetpath, sourcepath)) + sourcepath = None + else: + logger.debug('Unable to determine source file, proceeding anyway') + if modpatches: + logger.warn('File %s is modified by the following patches:\n %s' % (args.targetpath, '\n '.join(modpatches))) + + if instelements and sourcepath: + install = None + else: + # Auto-determine permissions + # Check destination + binpaths = '${bindir}:${sbindir}:${base_bindir}:${base_sbindir}:${libexecdir}:${sysconfdir}/init.d' + perms = '0644' + if os.path.abspath(os.path.dirname(args.targetpath)) in rd.expand(binpaths).split(':'): + # File is going into a directory normally reserved for executables, so it should be executable + perms = '0755' + else: + # Check source + st = os.stat(args.newfile) + if st.st_mode & stat.S_IXUSR: + perms = '0755' + install = {args.newfile: (args.targetpath, perms)} + oe.recipeutils.bbappend_recipe(rd, args.destlayer, {args.newfile: sourcepath}, install, wildcardver=args.wildcard_version, machine=args.machine) + return 0 + else: + if alternative_pns: + logger.error('File %s is an alternative possibly provided by the following recipes:\n %s\nPlease select recipe with -r/--recipe' % (targetpath, '\n '.join(alternative_pns))) + elif postinst_pns: + logger.error('File %s may be written out in a pre/postinstall script of the following recipes:\n %s\nPlease select recipe with -r/--recipe' % (targetpath, '\n '.join(postinst_pns))) + return 3 + + +def appendsrc(args, files, rd, extralines=None): + import oe.recipeutils + + srcdir = rd.getVar('S') + workdir = rd.getVar('WORKDIR') + + import bb.fetch + simplified = {} + src_uri = rd.getVar('SRC_URI').split() + for uri in src_uri: + if uri.endswith(';'): + uri = uri[:-1] + simple_uri = bb.fetch.URI(uri) + simple_uri.params = {} + simplified[str(simple_uri)] = uri + + copyfiles = {} + extralines = extralines or [] + for newfile, srcfile in files.items(): + src_destdir = os.path.dirname(srcfile) + if not args.use_workdir: + if rd.getVar('S') == rd.getVar('STAGING_KERNEL_DIR'): + srcdir = os.path.join(workdir, 'git') + if not bb.data.inherits_class('kernel-yocto', rd): + logger.warn('S == STAGING_KERNEL_DIR and non-kernel-yocto, unable to determine path to srcdir, defaulting to ${WORKDIR}/git') + src_destdir = os.path.join(os.path.relpath(srcdir, workdir), src_destdir) + src_destdir = os.path.normpath(src_destdir) + + source_uri = 'file://{0}'.format(os.path.basename(srcfile)) + if src_destdir and src_destdir != '.': + source_uri += ';subdir={0}'.format(src_destdir) + + simple = bb.fetch.URI(source_uri) + simple.params = {} + simple_str = str(simple) + if simple_str in simplified: + existing = simplified[simple_str] + if source_uri != existing: + logger.warn('{0!r} is already in SRC_URI, with different parameters: {1!r}, not adding'.format(source_uri, existing)) + else: + logger.warn('{0!r} is already in SRC_URI, not adding'.format(source_uri)) + else: + extralines.append('SRC_URI += {0}'.format(source_uri)) + copyfiles[newfile] = srcfile + + oe.recipeutils.bbappend_recipe(rd, args.destlayer, copyfiles, None, wildcardver=args.wildcard_version, machine=args.machine, extralines=extralines) + + +def appendsrcfiles(parser, args): + recipedata = _parse_recipe(args.recipe, tinfoil) + if not recipedata: + parser.error('RECIPE must be a valid recipe name') + + files = dict((f, os.path.join(args.destdir, os.path.basename(f))) + for f in args.files) + return appendsrc(args, files, recipedata) + + +def appendsrcfile(parser, args): + recipedata = _parse_recipe(args.recipe, tinfoil) + if not recipedata: + parser.error('RECIPE must be a valid recipe name') + + if not args.destfile: + args.destfile = os.path.basename(args.file) + elif args.destfile.endswith('/'): + args.destfile = os.path.join(args.destfile, os.path.basename(args.file)) + + return appendsrc(args, {args.file: args.destfile}, recipedata) + + +def layer(layerpath): + if not os.path.exists(os.path.join(layerpath, 'conf', 'layer.conf')): + raise argparse.ArgumentTypeError('{0!r} must be a path to a valid layer'.format(layerpath)) + return layerpath + + +def existing_path(filepath): + if not os.path.exists(filepath): + raise argparse.ArgumentTypeError('{0!r} must be an existing path'.format(filepath)) + return filepath + + +def existing_file(filepath): + filepath = existing_path(filepath) + if os.path.isdir(filepath): + raise argparse.ArgumentTypeError('{0!r} must be a file, not a directory'.format(filepath)) + return filepath + + +def destination_path(destpath): + if os.path.isabs(destpath): + raise argparse.ArgumentTypeError('{0!r} must be a relative path, not absolute'.format(destpath)) + return destpath + + +def target_path(targetpath): + if not os.path.isabs(targetpath): + raise argparse.ArgumentTypeError('{0!r} must be an absolute path, not relative'.format(targetpath)) + return targetpath + + +def register_commands(subparsers): + common = argparse.ArgumentParser(add_help=False) + common.add_argument('-m', '--machine', help='Make bbappend changes specific to a machine only', metavar='MACHINE') + common.add_argument('-w', '--wildcard-version', help='Use wildcard to make the bbappend apply to any recipe version', action='store_true') + common.add_argument('destlayer', metavar='DESTLAYER', help='Base directory of the destination layer to write the bbappend to', type=layer) + + parser_appendfile = subparsers.add_parser('appendfile', + parents=[common], + help='Create/update a bbappend to replace a target file', + description='Creates a bbappend (or updates an existing one) to replace the specified file that appears in the target system, determining the recipe that packages the file and the required path and name for the bbappend automatically. Note that the ability to determine the recipe packaging a particular file depends upon the recipe\'s do_packagedata task having already run prior to running this command (which it will have when the recipe has been built successfully, which in turn will have happened if one or more of the recipe\'s packages is included in an image that has been built successfully).') + parser_appendfile.add_argument('targetpath', help='Path to the file to be replaced (as it would appear within the target image, e.g. /etc/motd)', type=target_path) + parser_appendfile.add_argument('newfile', help='Custom file to replace the target file with', type=existing_file) + parser_appendfile.add_argument('-r', '--recipe', help='Override recipe to apply to (default is to find which recipe already packages the file)') + parser_appendfile.set_defaults(func=appendfile, parserecipes=True) + + common_src = argparse.ArgumentParser(add_help=False, parents=[common]) + common_src.add_argument('-W', '--workdir', help='Unpack file into WORKDIR rather than S', dest='use_workdir', action='store_true') + common_src.add_argument('recipe', metavar='RECIPE', help='Override recipe to apply to') + + parser = subparsers.add_parser('appendsrcfiles', + parents=[common_src], + help='Create/update a bbappend to add or replace source files', + description='Creates a bbappend (or updates an existing one) to add or replace the specified file in the recipe sources, either those in WORKDIR or those in the source tree. This command lets you specify multiple files with a destination directory, so cannot specify the destination filename. See the `appendsrcfile` command for the other behavior.') + parser.add_argument('-D', '--destdir', help='Destination directory (relative to S or WORKDIR, defaults to ".")', default='', type=destination_path) + parser.add_argument('files', nargs='+', metavar='FILE', help='File(s) to be added to the recipe sources (WORKDIR or S)', type=existing_path) + parser.set_defaults(func=lambda a: appendsrcfiles(parser, a), parserecipes=True) + + parser = subparsers.add_parser('appendsrcfile', + parents=[common_src], + help='Create/update a bbappend to add or replace a source file', + description='Creates a bbappend (or updates an existing one) to add or replace the specified files in the recipe sources, either those in WORKDIR or those in the source tree. This command lets you specify the destination filename, not just destination directory, but only works for one file. See the `appendsrcfiles` command for the other behavior.') + parser.add_argument('file', metavar='FILE', help='File to be added to the recipe sources (WORKDIR or S)', type=existing_path) + parser.add_argument('destfile', metavar='DESTFILE', nargs='?', help='Destination path (relative to S or WORKDIR, optional)', type=destination_path) + parser.set_defaults(func=lambda a: appendsrcfile(parser, a), parserecipes=True) diff --git a/scripts/lib/recipetool/create.py b/scripts/lib/recipetool/create.py new file mode 100644 index 0000000000..5af58a12f7 --- /dev/null +++ b/scripts/lib/recipetool/create.py @@ -0,0 +1,1165 @@ +# Recipe creation tool - create command plugin +# +# Copyright (C) 2014-2016 Intel Corporation +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +import sys +import os +import argparse +import glob +import fnmatch +import re +import json +import logging +import scriptutils +from urllib.parse import urlparse, urldefrag, urlsplit +import hashlib + +logger = logging.getLogger('recipetool') + +tinfoil = None +plugins = None + +def log_error_cond(message, debugonly): + if debugonly: + logger.debug(message) + else: + logger.error(message) + +def log_info_cond(message, debugonly): + if debugonly: + logger.debug(message) + else: + logger.info(message) + +def plugin_init(pluginlist): + # Take a reference to the list so we can use it later + global plugins + plugins = pluginlist + +def tinfoil_init(instance): + global tinfoil + tinfoil = instance + +class RecipeHandler(object): + recipelibmap = {} + recipeheadermap = {} + recipecmakefilemap = {} + recipebinmap = {} + + def __init__(self): + self._devtool = False + + @staticmethod + def load_libmap(d): + '''Load library->recipe mapping''' + import oe.package + + if RecipeHandler.recipelibmap: + return + # First build up library->package mapping + shlib_providers = oe.package.read_shlib_providers(d) + libdir = d.getVar('libdir') + base_libdir = d.getVar('base_libdir') + libpaths = list(set([base_libdir, libdir])) + libname_re = re.compile('^lib(.+)\.so.*$') + pkglibmap = {} + for lib, item in shlib_providers.items(): + for path, pkg in item.items(): + if path in libpaths: + res = libname_re.match(lib) + if res: + libname = res.group(1) + if not libname in pkglibmap: + pkglibmap[libname] = pkg[0] + else: + logger.debug('unable to extract library name from %s' % lib) + + # Now turn it into a library->recipe mapping + pkgdata_dir = d.getVar('PKGDATA_DIR') + for libname, pkg in pkglibmap.items(): + try: + with open(os.path.join(pkgdata_dir, 'runtime', pkg)) as f: + for line in f: + if line.startswith('PN:'): + RecipeHandler.recipelibmap[libname] = line.split(':', 1)[-1].strip() + break + except IOError as ioe: + if ioe.errno == 2: + logger.warn('unable to find a pkgdata file for package %s' % pkg) + else: + raise + + # Some overrides - these should be mapped to the virtual + RecipeHandler.recipelibmap['GL'] = 'virtual/libgl' + RecipeHandler.recipelibmap['EGL'] = 'virtual/egl' + RecipeHandler.recipelibmap['GLESv2'] = 'virtual/libgles2' + + @staticmethod + def load_devel_filemap(d): + '''Build up development file->recipe mapping''' + if RecipeHandler.recipeheadermap: + return + pkgdata_dir = d.getVar('PKGDATA_DIR') + includedir = d.getVar('includedir') + cmakedir = os.path.join(d.getVar('libdir'), 'cmake') + for pkg in glob.glob(os.path.join(pkgdata_dir, 'runtime', '*-dev')): + with open(os.path.join(pkgdata_dir, 'runtime', pkg)) as f: + pn = None + headers = [] + cmakefiles = [] + for line in f: + if line.startswith('PN:'): + pn = line.split(':', 1)[-1].strip() + elif line.startswith('FILES_INFO:'): + val = line.split(':', 1)[1].strip() + dictval = json.loads(val) + for fullpth in sorted(dictval): + if fullpth.startswith(includedir) and fullpth.endswith('.h'): + headers.append(os.path.relpath(fullpth, includedir)) + elif fullpth.startswith(cmakedir) and fullpth.endswith('.cmake'): + cmakefiles.append(os.path.relpath(fullpth, cmakedir)) + if pn and headers: + for header in headers: + RecipeHandler.recipeheadermap[header] = pn + if pn and cmakefiles: + for fn in cmakefiles: + RecipeHandler.recipecmakefilemap[fn] = pn + + @staticmethod + def load_binmap(d): + '''Build up native binary->recipe mapping''' + if RecipeHandler.recipebinmap: + return + sstate_manifests = d.getVar('SSTATE_MANIFESTS') + staging_bindir_native = d.getVar('STAGING_BINDIR_NATIVE') + build_arch = d.getVar('BUILD_ARCH') + fileprefix = 'manifest-%s-' % build_arch + for fn in glob.glob(os.path.join(sstate_manifests, '%s*-native.populate_sysroot' % fileprefix)): + with open(fn, 'r') as f: + pn = os.path.basename(fn).rsplit('.', 1)[0][len(fileprefix):] + for line in f: + if line.startswith(staging_bindir_native): + prog = os.path.basename(line.rstrip()) + RecipeHandler.recipebinmap[prog] = pn + + @staticmethod + def checkfiles(path, speclist, recursive=False): + results = [] + if recursive: + for root, _, files in os.walk(path): + for fn in files: + for spec in speclist: + if fnmatch.fnmatch(fn, spec): + results.append(os.path.join(root, fn)) + else: + for spec in speclist: + results.extend(glob.glob(os.path.join(path, spec))) + return results + + @staticmethod + def handle_depends(libdeps, pcdeps, deps, outlines, values, d): + if pcdeps: + recipemap = read_pkgconfig_provides(d) + if libdeps: + RecipeHandler.load_libmap(d) + + ignorelibs = ['socket'] + ignoredeps = ['gcc-runtime', 'glibc', 'uclibc', 'musl', 'tar-native', 'binutils-native', 'coreutils-native'] + + unmappedpc = [] + pcdeps = list(set(pcdeps)) + for pcdep in pcdeps: + if isinstance(pcdep, str): + recipe = recipemap.get(pcdep, None) + if recipe: + deps.append(recipe) + else: + if not pcdep.startswith('$'): + unmappedpc.append(pcdep) + else: + for item in pcdep: + recipe = recipemap.get(pcdep, None) + if recipe: + deps.append(recipe) + break + else: + unmappedpc.append('(%s)' % ' or '.join(pcdep)) + + unmappedlibs = [] + for libdep in libdeps: + if isinstance(libdep, tuple): + lib, header = libdep + else: + lib = libdep + header = None + + if lib in ignorelibs: + logger.debug('Ignoring library dependency %s' % lib) + continue + + recipe = RecipeHandler.recipelibmap.get(lib, None) + if recipe: + deps.append(recipe) + elif recipe is None: + if header: + RecipeHandler.load_devel_filemap(d) + recipe = RecipeHandler.recipeheadermap.get(header, None) + if recipe: + deps.append(recipe) + elif recipe is None: + unmappedlibs.append(lib) + else: + unmappedlibs.append(lib) + + deps = set(deps).difference(set(ignoredeps)) + + if unmappedpc: + outlines.append('# NOTE: unable to map the following pkg-config dependencies: %s' % ' '.join(unmappedpc)) + outlines.append('# (this is based on recipes that have previously been built and packaged)') + + if unmappedlibs: + outlines.append('# NOTE: the following library dependencies are unknown, ignoring: %s' % ' '.join(list(set(unmappedlibs)))) + outlines.append('# (this is based on recipes that have previously been built and packaged)') + + if deps: + values['DEPENDS'] = ' '.join(deps) + + @staticmethod + def genfunction(outlines, funcname, content, python=False, forcespace=False): + if python: + prefix = 'python ' + else: + prefix = '' + outlines.append('%s%s () {' % (prefix, funcname)) + if python or forcespace: + indent = ' ' + else: + indent = '\t' + addnoop = not python + for line in content: + outlines.append('%s%s' % (indent, line)) + if addnoop: + strippedline = line.lstrip() + if strippedline and not strippedline.startswith('#'): + addnoop = False + if addnoop: + # Without this there'll be a syntax error + outlines.append('%s:' % indent) + outlines.append('}') + outlines.append('') + + def process(self, srctree, classes, lines_before, lines_after, handled, extravalues): + return False + + +def validate_pv(pv): + if not pv or '_version' in pv.lower() or pv[0] not in '0123456789': + return False + return True + +def determine_from_filename(srcfile): + """Determine name and version from a filename""" + if is_package(srcfile): + # Force getting the value from the package metadata + return None, None + + if '.tar.' in srcfile: + namepart = srcfile.split('.tar.')[0] + else: + namepart = os.path.splitext(srcfile)[0] + namepart = namepart.lower().replace('_', '-') + if namepart.endswith('.src'): + namepart = namepart[:-4] + if namepart.endswith('.orig'): + namepart = namepart[:-5] + splitval = namepart.split('-') + logger.debug('determine_from_filename: split name %s into: %s' % (srcfile, splitval)) + + ver_re = re.compile('^v?[0-9]') + + pv = None + pn = None + if len(splitval) == 1: + # Try to split the version out if there is no separator (or a .) + res = re.match('^([^0-9]+)([0-9.]+.*)$', namepart) + if res: + if len(res.group(1)) > 1 and len(res.group(2)) > 1: + pn = res.group(1).rstrip('.') + pv = res.group(2) + else: + pn = namepart + else: + if splitval[-1] in ['source', 'src']: + splitval.pop() + if len(splitval) > 2 and re.match('^(alpha|beta|stable|release|rc[0-9]|pre[0-9]|p[0-9]|[0-9]{8})', splitval[-1]) and ver_re.match(splitval[-2]): + pv = '-'.join(splitval[-2:]) + if pv.endswith('-release'): + pv = pv[:-8] + splitval = splitval[:-2] + elif ver_re.match(splitval[-1]): + pv = splitval.pop() + pn = '-'.join(splitval) + if pv and pv.startswith('v'): + pv = pv[1:] + logger.debug('determine_from_filename: name = "%s" version = "%s"' % (pn, pv)) + return (pn, pv) + +def determine_from_url(srcuri): + """Determine name and version from a URL""" + pn = None + pv = None + parseres = urlparse(srcuri.lower().split(';', 1)[0]) + if parseres.path: + if 'github.com' in parseres.netloc: + res = re.search(r'.*/(.*?)/archive/(.*)-final\.(tar|zip)', parseres.path) + if res: + pn = res.group(1).strip().replace('_', '-') + pv = res.group(2).strip().replace('_', '.') + else: + res = re.search(r'.*/(.*?)/archive/v?(.*)\.(tar|zip)', parseres.path) + if res: + pn = res.group(1).strip().replace('_', '-') + pv = res.group(2).strip().replace('_', '.') + elif 'bitbucket.org' in parseres.netloc: + res = re.search(r'.*/(.*?)/get/[a-zA-Z_-]*([0-9][0-9a-zA-Z_.]*)\.(tar|zip)', parseres.path) + if res: + pn = res.group(1).strip().replace('_', '-') + pv = res.group(2).strip().replace('_', '.') + + if not pn and not pv and parseres.scheme not in ['git', 'gitsm', 'svn', 'hg']: + srcfile = os.path.basename(parseres.path.rstrip('/')) + pn, pv = determine_from_filename(srcfile) + + logger.debug('Determined from source URL: name = "%s", version = "%s"' % (pn, pv)) + return (pn, pv) + +def supports_srcrev(uri): + localdata = bb.data.createCopy(tinfoil.config_data) + # This is a bit sad, but if you don't have this set there can be some + # odd interactions with the urldata cache which lead to errors + localdata.setVar('SRCREV', '${AUTOREV}') + try: + fetcher = bb.fetch2.Fetch([uri], localdata) + urldata = fetcher.ud + for u in urldata: + if urldata[u].method.supports_srcrev(): + return True + except bb.fetch2.FetchError as e: + logger.debug('FetchError in supports_srcrev: %s' % str(e)) + # Fall back to basic check + if uri.startswith(('git://', 'gitsm://')): + return True + return False + +def reformat_git_uri(uri): + '''Convert any http[s]://....git URI into git://...;protocol=http[s]''' + checkuri = uri.split(';', 1)[0] + if checkuri.endswith('.git') or '/git/' in checkuri or re.match('https?://github.com/[^/]+/[^/]+/?$', checkuri): + res = re.match('(http|https|ssh)://([^;]+(\.git)?)(;.*)?$', uri) + if res: + # Need to switch the URI around so that the git fetcher is used + return 'git://%s;protocol=%s%s' % (res.group(2), res.group(1), res.group(4) or '') + elif '@' in checkuri: + # Catch e.g. git@git.example.com:repo.git + return 'git://%s;protocol=ssh' % checkuri.replace(':', '/', 1) + return uri + +def is_package(url): + '''Check if a URL points to a package''' + checkurl = url.split(';', 1)[0] + if checkurl.endswith(('.deb', '.ipk', '.rpm', '.srpm')): + return True + return False + +def create_recipe(args): + import bb.process + import tempfile + import shutil + import oe.recipeutils + + pkgarch = "" + if args.machine: + pkgarch = "${MACHINE_ARCH}" + + extravalues = {} + checksums = (None, None) + tempsrc = '' + source = args.source + srcsubdir = '' + srcrev = '${AUTOREV}' + + if os.path.isfile(source): + source = 'file://%s' % os.path.abspath(source) + + if scriptutils.is_src_url(source): + # Fetch a URL + fetchuri = reformat_git_uri(urldefrag(source)[0]) + if args.binary: + # Assume the archive contains the directory structure verbatim + # so we need to extract to a subdirectory + fetchuri += ';subdir=${BP}' + srcuri = fetchuri + rev_re = re.compile(';rev=([^;]+)') + res = rev_re.search(srcuri) + if res: + srcrev = res.group(1) + srcuri = rev_re.sub('', srcuri) + tempsrc = tempfile.mkdtemp(prefix='recipetool-') + srctree = tempsrc + d = bb.data.createCopy(tinfoil.config_data) + if fetchuri.startswith('npm://'): + # Check if npm is available + npm_bindir = check_npm(tinfoil, args.devtool) + d.prependVar('PATH', '%s:' % npm_bindir) + logger.info('Fetching %s...' % srcuri) + try: + checksums = scriptutils.fetch_uri(d, fetchuri, srctree, srcrev) + except bb.fetch2.BBFetchException as e: + logger.error(str(e).rstrip()) + sys.exit(1) + dirlist = os.listdir(srctree) + if 'git.indirectionsymlink' in dirlist: + dirlist.remove('git.indirectionsymlink') + if len(dirlist) == 1: + singleitem = os.path.join(srctree, dirlist[0]) + if os.path.isdir(singleitem): + # We unpacked a single directory, so we should use that + srcsubdir = dirlist[0] + srctree = os.path.join(srctree, srcsubdir) + else: + with open(singleitem, 'r', errors='surrogateescape') as f: + if '<html' in f.read(100).lower(): + logger.error('Fetching "%s" returned a single HTML page - check the URL is correct and functional' % fetchuri) + sys.exit(1) + if os.path.exists(os.path.join(srctree, '.gitmodules')) and srcuri.startswith('git://'): + srcuri = 'gitsm://' + srcuri[6:] + logger.info('Fetching submodules...') + bb.process.run('git submodule update --init --recursive', cwd=srctree) + + if is_package(fetchuri): + tmpfdir = tempfile.mkdtemp(prefix='recipetool-') + try: + pkgfile = None + try: + fileuri = fetchuri + ';unpack=0' + scriptutils.fetch_uri(tinfoil.config_data, fileuri, tmpfdir, srcrev) + for root, _, files in os.walk(tmpfdir): + for f in files: + pkgfile = os.path.join(root, f) + break + except bb.fetch2.BBFetchException as e: + logger.warn('Second fetch to get metadata failed: %s' % str(e).rstrip()) + + if pkgfile: + if pkgfile.endswith(('.deb', '.ipk')): + stdout, _ = bb.process.run('ar x %s' % pkgfile, cwd=tmpfdir) + stdout, _ = bb.process.run('tar xf control.tar.gz', cwd=tmpfdir) + values = convert_debian(tmpfdir) + extravalues.update(values) + elif pkgfile.endswith(('.rpm', '.srpm')): + stdout, _ = bb.process.run('rpm -qp --xml %s > pkginfo.xml' % pkgfile, cwd=tmpfdir) + values = convert_rpm_xml(os.path.join(tmpfdir, 'pkginfo.xml')) + extravalues.update(values) + finally: + shutil.rmtree(tmpfdir) + else: + # Assume we're pointing to an existing source tree + if args.extract_to: + logger.error('--extract-to cannot be specified if source is a directory') + sys.exit(1) + if not os.path.isdir(source): + logger.error('Invalid source directory %s' % source) + sys.exit(1) + srctree = source + srcuri = '' + if os.path.exists(os.path.join(srctree, '.git')): + # Try to get upstream repo location from origin remote + try: + stdout, _ = bb.process.run('git remote -v', cwd=srctree, shell=True) + except bb.process.ExecutionError as e: + stdout = None + if stdout: + for line in stdout.splitlines(): + splitline = line.split() + if len(splitline) > 1: + if splitline[0] == 'origin' and scriptutils.is_src_url(splitline[1]): + srcuri = reformat_git_uri(splitline[1]) + srcsubdir = 'git' + break + + if args.src_subdir: + srcsubdir = os.path.join(srcsubdir, args.src_subdir) + srctree_use = os.path.join(srctree, args.src_subdir) + else: + srctree_use = srctree + + if args.outfile and os.path.isdir(args.outfile): + outfile = None + outdir = args.outfile + else: + outfile = args.outfile + outdir = None + if outfile and outfile != '-': + if os.path.exists(outfile): + logger.error('Output file %s already exists' % outfile) + sys.exit(1) + + lines_before = [] + lines_after = [] + + lines_before.append('# Recipe created by %s' % os.path.basename(sys.argv[0])) + lines_before.append('# This is the basis of a recipe and may need further editing in order to be fully functional.') + lines_before.append('# (Feel free to remove these comments when editing.)') + # We need a blank line here so that patch_recipe_lines can rewind before the LICENSE comments + lines_before.append('') + + handled = [] + licvalues = handle_license_vars(srctree_use, lines_before, handled, extravalues, tinfoil.config_data) + + classes = [] + + # FIXME This is kind of a hack, we probably ought to be using bitbake to do this + pn = None + pv = None + if outfile: + recipefn = os.path.splitext(os.path.basename(outfile))[0] + fnsplit = recipefn.split('_') + if len(fnsplit) > 1: + pn = fnsplit[0] + pv = fnsplit[1] + else: + pn = recipefn + + if args.version: + pv = args.version + + if args.name: + pn = args.name + if args.name.endswith('-native'): + if args.also_native: + logger.error('--also-native cannot be specified for a recipe named *-native (*-native denotes a recipe that is already only for native) - either remove the -native suffix from the name or drop --also-native') + sys.exit(1) + classes.append('native') + elif args.name.startswith('nativesdk-'): + if args.also_native: + logger.error('--also-native cannot be specified for a recipe named nativesdk-* (nativesdk-* denotes a recipe that is already only for nativesdk)') + sys.exit(1) + classes.append('nativesdk') + + if pv and pv not in 'git svn hg'.split(): + realpv = pv + else: + realpv = None + + if srcuri and not realpv or not pn: + name_pn, name_pv = determine_from_url(srcuri) + if name_pn and not pn: + pn = name_pn + if name_pv and not realpv: + realpv = name_pv + + if not srcuri: + lines_before.append('# No information for SRC_URI yet (only an external source tree was specified)') + lines_before.append('SRC_URI = "%s"' % srcuri) + (md5value, sha256value) = checksums + if md5value: + lines_before.append('SRC_URI[md5sum] = "%s"' % md5value) + if sha256value: + lines_before.append('SRC_URI[sha256sum] = "%s"' % sha256value) + if srcuri and supports_srcrev(srcuri): + lines_before.append('') + lines_before.append('# Modify these as desired') + lines_before.append('PV = "%s+git${SRCPV}"' % (realpv or '1.0')) + if not args.autorev and srcrev == '${AUTOREV}': + if os.path.exists(os.path.join(srctree, '.git')): + (stdout, _) = bb.process.run('git rev-parse HEAD', cwd=srctree) + srcrev = stdout.rstrip() + lines_before.append('SRCREV = "%s"' % srcrev) + lines_before.append('') + + if srcsubdir and not args.binary: + # (for binary packages we explicitly specify subdir= when fetching to + # match the default value of S, so we don't need to set it in that case) + lines_before.append('S = "${WORKDIR}/%s"' % srcsubdir) + lines_before.append('') + + if pkgarch: + lines_after.append('PACKAGE_ARCH = "%s"' % pkgarch) + lines_after.append('') + + if args.binary: + lines_after.append('INSANE_SKIP_${PN} += "already-stripped"') + lines_after.append('') + + if args.fetch_dev: + extravalues['fetchdev'] = True + else: + extravalues['fetchdev'] = None + + # Find all plugins that want to register handlers + logger.debug('Loading recipe handlers') + raw_handlers = [] + for plugin in plugins: + if hasattr(plugin, 'register_recipe_handlers'): + plugin.register_recipe_handlers(raw_handlers) + # Sort handlers by priority + handlers = [] + for i, handler in enumerate(raw_handlers): + if isinstance(handler, tuple): + handlers.append((handler[0], handler[1], i)) + else: + handlers.append((handler, 0, i)) + handlers.sort(key=lambda item: (item[1], -item[2]), reverse=True) + for handler, priority, _ in handlers: + logger.debug('Handler: %s (priority %d)' % (handler.__class__.__name__, priority)) + setattr(handler, '_devtool', args.devtool) + handlers = [item[0] for item in handlers] + + # Apply the handlers + if args.binary: + classes.append('bin_package') + handled.append('buildsystem') + + for handler in handlers: + handler.process(srctree_use, classes, lines_before, lines_after, handled, extravalues) + + extrafiles = extravalues.pop('extrafiles', {}) + extra_pn = extravalues.pop('PN', None) + extra_pv = extravalues.pop('PV', None) + + if extra_pv and not realpv: + realpv = extra_pv + if not validate_pv(realpv): + realpv = None + else: + realpv = realpv.lower().split()[0] + if '_' in realpv: + realpv = realpv.replace('_', '-') + if extra_pn and not pn: + pn = extra_pn + if pn.startswith('GNU '): + pn = pn[4:] + if ' ' in pn: + # Probably a descriptive identifier rather than a proper name + pn = None + else: + pn = pn.lower() + if '_' in pn: + pn = pn.replace('_', '-') + + if not outfile: + if not pn: + log_error_cond('Unable to determine short program name from source tree - please specify name with -N/--name or output file name with -o/--outfile', args.devtool) + # devtool looks for this specific exit code, so don't change it + sys.exit(15) + else: + if srcuri and srcuri.startswith(('gitsm://', 'git://', 'hg://', 'svn://')): + suffix = srcuri.split(':', 1)[0] + if suffix == 'gitsm': + suffix = 'git' + outfile = '%s_%s.bb' % (pn, suffix) + elif realpv: + outfile = '%s_%s.bb' % (pn, realpv) + else: + outfile = '%s.bb' % pn + if outdir: + outfile = os.path.join(outdir, outfile) + # We need to check this again + if os.path.exists(outfile): + logger.error('Output file %s already exists' % outfile) + sys.exit(1) + + # Move any extra files the plugins created to a directory next to the recipe + if extrafiles: + if outfile == '-': + extraoutdir = pn + else: + extraoutdir = os.path.join(os.path.dirname(outfile), pn) + bb.utils.mkdirhier(extraoutdir) + for destfn, extrafile in extrafiles.items(): + shutil.move(extrafile, os.path.join(extraoutdir, destfn)) + + lines = lines_before + lines_before = [] + skipblank = True + for line in lines: + if skipblank: + skipblank = False + if not line: + continue + if line.startswith('S = '): + if realpv and pv not in 'git svn hg'.split(): + line = line.replace(realpv, '${PV}') + if pn: + line = line.replace(pn, '${BPN}') + if line == 'S = "${WORKDIR}/${BPN}-${PV}"': + skipblank = True + continue + elif line.startswith('SRC_URI = '): + if realpv: + line = line.replace(realpv, '${PV}') + elif line.startswith('PV = '): + if realpv: + line = re.sub('"[^+]*\+', '"%s+' % realpv, line) + lines_before.append(line) + + if args.also_native: + lines = lines_after + lines_after = [] + bbclassextend = None + for line in lines: + if line.startswith('BBCLASSEXTEND ='): + splitval = line.split('"') + if len(splitval) > 1: + bbclassextend = splitval[1].split() + if not 'native' in bbclassextend: + bbclassextend.insert(0, 'native') + line = 'BBCLASSEXTEND = "%s"' % ' '.join(bbclassextend) + lines_after.append(line) + if not bbclassextend: + lines_after.append('BBCLASSEXTEND = "native"') + + postinst = ("postinst", extravalues.pop('postinst', None)) + postrm = ("postrm", extravalues.pop('postrm', None)) + preinst = ("preinst", extravalues.pop('preinst', None)) + prerm = ("prerm", extravalues.pop('prerm', None)) + funcs = [postinst, postrm, preinst, prerm] + for func in funcs: + if func[1]: + RecipeHandler.genfunction(lines_after, 'pkg_%s_${PN}' % func[0], func[1]) + + outlines = [] + outlines.extend(lines_before) + if classes: + if outlines[-1] and not outlines[-1].startswith('#'): + outlines.append('') + outlines.append('inherit %s' % ' '.join(classes)) + outlines.append('') + outlines.extend(lines_after) + + if extravalues: + if 'LICENSE' in extravalues and not licvalues: + # Don't blow away 'CLOSED' value that comments say we set + del extravalues['LICENSE'] + _, outlines = oe.recipeutils.patch_recipe_lines(outlines, extravalues, trailing_newline=False) + + if args.extract_to: + scriptutils.git_convert_standalone_clone(srctree) + if os.path.isdir(args.extract_to): + # If the directory exists we'll move the temp dir into it instead of + # its contents - of course, we could try to always move its contents + # but that is a pain if there are symlinks; the simplest solution is + # to just remove it first + os.rmdir(args.extract_to) + shutil.move(srctree, args.extract_to) + if tempsrc == srctree: + tempsrc = None + log_info_cond('Source extracted to %s' % args.extract_to, args.devtool) + + if outfile == '-': + sys.stdout.write('\n'.join(outlines) + '\n') + else: + with open(outfile, 'w') as f: + lastline = None + for line in outlines: + if not lastline and not line: + # Skip extra blank lines + continue + f.write('%s\n' % line) + lastline = line + log_info_cond('Recipe %s has been created; further editing may be required to make it fully functional' % outfile, args.devtool) + + if tempsrc: + if args.keep_temp: + logger.info('Preserving temporary directory %s' % tempsrc) + else: + shutil.rmtree(tempsrc) + + return 0 + +def handle_license_vars(srctree, lines_before, handled, extravalues, d): + licvalues = guess_license(srctree, d) + lic_files_chksum = [] + lic_unknown = [] + if licvalues: + licenses = [] + for licvalue in licvalues: + if not licvalue[0] in licenses: + licenses.append(licvalue[0]) + lic_files_chksum.append('file://%s;md5=%s' % (licvalue[1], licvalue[2])) + if licvalue[0] == 'Unknown': + lic_unknown.append(licvalue[1]) + lines_before.append('# WARNING: the following LICENSE and LIC_FILES_CHKSUM values are best guesses - it is') + lines_before.append('# your responsibility to verify that the values are complete and correct.') + if len(licvalues) > 1: + lines_before.append('#') + lines_before.append('# NOTE: multiple licenses have been detected; they have been separated with &') + lines_before.append('# in the LICENSE value for now since it is a reasonable assumption that all') + lines_before.append('# of the licenses apply. If instead there is a choice between the multiple') + lines_before.append('# licenses then you should change the value to separate the licenses with |') + lines_before.append('# instead of &. If there is any doubt, check the accompanying documentation') + lines_before.append('# to determine which situation is applicable.') + if lic_unknown: + lines_before.append('#') + lines_before.append('# The following license files were not able to be identified and are') + lines_before.append('# represented as "Unknown" below, you will need to check them yourself:') + for licfile in lic_unknown: + lines_before.append('# %s' % licfile) + lines_before.append('#') + else: + lines_before.append('# Unable to find any files that looked like license statements. Check the accompanying') + lines_before.append('# documentation and source headers and set LICENSE and LIC_FILES_CHKSUM accordingly.') + lines_before.append('#') + lines_before.append('# NOTE: LICENSE is being set to "CLOSED" to allow you to at least start building - if') + lines_before.append('# this is not accurate with respect to the licensing of the software being built (it') + lines_before.append('# will not be in most cases) you must specify the correct value before using this') + lines_before.append('# recipe for anything other than initial testing/development!') + licenses = ['CLOSED'] + pkg_license = extravalues.pop('LICENSE', None) + if pkg_license: + if licenses == ['Unknown']: + lines_before.append('# NOTE: The following LICENSE value was determined from the original package metadata') + licenses = [pkg_license] + else: + lines_before.append('# NOTE: Original package metadata indicates license is: %s' % pkg_license) + lines_before.append('LICENSE = "%s"' % ' & '.join(licenses)) + lines_before.append('LIC_FILES_CHKSUM = "%s"' % ' \\\n '.join(lic_files_chksum)) + lines_before.append('') + handled.append(('license', licvalues)) + return licvalues + +def get_license_md5sums(d, static_only=False): + import bb.utils + md5sums = {} + if not static_only: + # Gather md5sums of license files in common license dir + commonlicdir = d.getVar('COMMON_LICENSE_DIR') + for fn in os.listdir(commonlicdir): + md5value = bb.utils.md5_file(os.path.join(commonlicdir, fn)) + md5sums[md5value] = fn + # The following were extracted from common values in various recipes + # (double checking the license against the license file itself, not just + # the LICENSE value in the recipe) + md5sums['94d55d512a9ba36caa9b7df079bae19f'] = 'GPLv2' + md5sums['b234ee4d69f5fce4486a80fdaf4a4263'] = 'GPLv2' + md5sums['59530bdf33659b29e73d4adb9f9f6552'] = 'GPLv2' + md5sums['0636e73ff0215e8d672dc4c32c317bb3'] = 'GPLv2' + md5sums['eb723b61539feef013de476e68b5c50a'] = 'GPLv2' + md5sums['751419260aa954499f7abaabaa882bbe'] = 'GPLv2' + md5sums['393a5ca445f6965873eca0259a17f833'] = 'GPLv2' + md5sums['12f884d2ae1ff87c09e5b7ccc2c4ca7e'] = 'GPLv2' + md5sums['8ca43cbc842c2336e835926c2166c28b'] = 'GPLv2' + md5sums['ebb5c50ab7cab4baeffba14977030c07'] = 'GPLv2' + md5sums['c93c0550bd3173f4504b2cbd8991e50b'] = 'GPLv2' + md5sums['9ac2e7cff1ddaf48b6eab6028f23ef88'] = 'GPLv2' + md5sums['4325afd396febcb659c36b49533135d4'] = 'GPLv2' + md5sums['18810669f13b87348459e611d31ab760'] = 'GPLv2' + md5sums['d7810fab7487fb0aad327b76f1be7cd7'] = 'GPLv2' # the Linux kernel's COPYING file + md5sums['bbb461211a33b134d42ed5ee802b37ff'] = 'LGPLv2.1' + md5sums['7fbc338309ac38fefcd64b04bb903e34'] = 'LGPLv2.1' + md5sums['4fbd65380cdd255951079008b364516c'] = 'LGPLv2.1' + md5sums['2d5025d4aa3495befef8f17206a5b0a1'] = 'LGPLv2.1' + md5sums['fbc093901857fcd118f065f900982c24'] = 'LGPLv2.1' + md5sums['a6f89e2100d9b6cdffcea4f398e37343'] = 'LGPLv2.1' + md5sums['d8045f3b8f929c1cb29a1e3fd737b499'] = 'LGPLv2.1' + md5sums['fad9b3332be894bab9bc501572864b29'] = 'LGPLv2.1' + md5sums['3bf50002aefd002f49e7bb854063f7e7'] = 'LGPLv2' + md5sums['9f604d8a4f8e74f4f5140845a21b6674'] = 'LGPLv2' + md5sums['5f30f0716dfdd0d91eb439ebec522ec2'] = 'LGPLv2' + md5sums['55ca817ccb7d5b5b66355690e9abc605'] = 'LGPLv2' + md5sums['252890d9eee26aab7b432e8b8a616475'] = 'LGPLv2' + md5sums['3214f080875748938ba060314b4f727d'] = 'LGPLv2' + md5sums['db979804f025cf55aabec7129cb671ed'] = 'LGPLv2' + md5sums['d32239bcb673463ab874e80d47fae504'] = 'GPLv3' + md5sums['f27defe1e96c2e1ecd4e0c9be8967949'] = 'GPLv3' + md5sums['6a6a8e020838b23406c81b19c1d46df6'] = 'LGPLv3' + md5sums['3b83ef96387f14655fc854ddc3c6bd57'] = 'Apache-2.0' + md5sums['385c55653886acac3821999a3ccd17b3'] = 'Artistic-1.0 | GPL-2.0' # some perl modules + md5sums['54c7042be62e169199200bc6477f04d1'] = 'BSD-3-Clause' + return md5sums + +def crunch_license(licfile): + ''' + Remove non-material text from a license file and then check + its md5sum against a known list. This works well for licenses + which contain a copyright statement, but is also a useful way + to handle people's insistence upon reformatting the license text + slightly (with no material difference to the text of the + license). + ''' + + import oe.utils + + # Note: these are carefully constructed! + license_title_re = re.compile('^\(?(#+ *)?(The )?.{1,10} [Ll]icen[sc]e( \(.{1,10}\))?\)?:?$') + license_statement_re = re.compile('^(This (project|software) is( free software)? (released|licen[sc]ed)|(Released|Licen[cs]ed)) under the .{1,10} [Ll]icen[sc]e:?$') + copyright_re = re.compile('^(#+)? *Copyright .*$') + + crunched_md5sums = {} + # The following two were gleaned from the "forever" npm package + crunched_md5sums['0a97f8e4cbaf889d6fa51f84b89a79f6'] = 'ISC' + crunched_md5sums['eecf6429523cbc9693547cf2db790b5c'] = 'MIT' + # https://github.com/vasi/pixz/blob/master/LICENSE + crunched_md5sums['2f03392b40bbe663597b5bd3cc5ebdb9'] = 'BSD-2-Clause' + # https://github.com/waffle-gl/waffle/blob/master/LICENSE.txt + crunched_md5sums['e72e5dfef0b1a4ca8a3d26a60587db66'] = 'BSD-2-Clause' + # https://github.com/spigwitmer/fakeds1963s/blob/master/LICENSE + crunched_md5sums['8be76ac6d191671f347ee4916baa637e'] = 'GPLv2' + # https://github.com/datto/dattobd/blob/master/COPYING + # http://git.savannah.gnu.org/cgit/freetype/freetype2.git/tree/docs/GPLv2.TXT + crunched_md5sums['1d65c5ad4bf6489f85f4812bf08ae73d'] = 'GPLv2' + # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt + # http://git.neil.brown.name/?p=mdadm.git;a=blob;f=COPYING;h=d159169d1050894d3ea3b98e1c965c4058208fe1;hb=HEAD + crunched_md5sums['fb530f66a7a89ce920f0e912b5b66d4b'] = 'GPLv2' + # https://github.com/gkos/nrf24/blob/master/COPYING + crunched_md5sums['7b6aaa4daeafdfa6ed5443fd2684581b'] = 'GPLv2' + # https://github.com/josch09/resetusb/blob/master/COPYING + crunched_md5sums['8b8ac1d631a4d220342e83bcf1a1fbc3'] = 'GPLv3' + # https://github.com/FFmpeg/FFmpeg/blob/master/COPYING.LGPLv2.1 + crunched_md5sums['2ea316ed973ae176e502e2297b574bb3'] = 'LGPLv2.1' + # unixODBC-2.3.4 COPYING + crunched_md5sums['1daebd9491d1e8426900b4fa5a422814'] = 'LGPLv2.1' + # https://github.com/FFmpeg/FFmpeg/blob/master/COPYING.LGPLv3 + crunched_md5sums['2ebfb3bb49b9a48a075cc1425e7f4129'] = 'LGPLv3' + lictext = [] + with open(licfile, 'r', errors='surrogateescape') as f: + for line in f: + # Drop opening statements + if copyright_re.match(line): + continue + elif license_title_re.match(line): + continue + elif license_statement_re.match(line): + continue + # Squash spaces, and replace smart quotes, double quotes + # and backticks with single quotes + line = oe.utils.squashspaces(line.strip()) + line = line.replace(u"\u2018", "'").replace(u"\u2019", "'").replace(u"\u201c","'").replace(u"\u201d", "'").replace('"', '\'').replace('`', '\'') + if line: + lictext.append(line) + + m = hashlib.md5() + try: + m.update(' '.join(lictext).encode('utf-8')) + md5val = m.hexdigest() + except UnicodeEncodeError: + md5val = None + lictext = '' + license = crunched_md5sums.get(md5val, None) + return license, md5val, lictext + +def guess_license(srctree, d): + import bb + md5sums = get_license_md5sums(d) + + licenses = [] + licspecs = ['*LICEN[CS]E*', 'COPYING*', '*[Ll]icense*', 'LEGAL*', '[Ll]egal*', '*GPL*', 'README.lic*', 'COPYRIGHT*', '[Cc]opyright*'] + licfiles = [] + for root, dirs, files in os.walk(srctree): + for fn in files: + for spec in licspecs: + if fnmatch.fnmatch(fn, spec): + fullpath = os.path.join(root, fn) + if not fullpath in licfiles: + licfiles.append(fullpath) + for licfile in licfiles: + md5value = bb.utils.md5_file(licfile) + license = md5sums.get(md5value, None) + if not license: + license, crunched_md5, lictext = crunch_license(licfile) + if not license: + license = 'Unknown' + licenses.append((license, os.path.relpath(licfile, srctree), md5value)) + + # FIXME should we grab at least one source file with a license header and add that too? + + return licenses + +def split_pkg_licenses(licvalues, packages, outlines, fallback_licenses=None, pn='${PN}'): + """ + Given a list of (license, path, md5sum) as returned by guess_license(), + a dict of package name to path mappings, write out a set of + package-specific LICENSE values. + """ + pkglicenses = {pn: []} + for license, licpath, _ in licvalues: + for pkgname, pkgpath in packages.items(): + if licpath.startswith(pkgpath + '/'): + if pkgname in pkglicenses: + pkglicenses[pkgname].append(license) + else: + pkglicenses[pkgname] = [license] + break + else: + # Accumulate on the main package + pkglicenses[pn].append(license) + outlicenses = {} + for pkgname in packages: + license = ' '.join(list(set(pkglicenses.get(pkgname, ['Unknown'])))) or 'Unknown' + if license == 'Unknown' and pkgname in fallback_licenses: + license = fallback_licenses[pkgname] + outlines.append('LICENSE_%s = "%s"' % (pkgname, license)) + outlicenses[pkgname] = license.split() + return outlicenses + +def read_pkgconfig_provides(d): + pkgdatadir = d.getVar('PKGDATA_DIR') + pkgmap = {} + for fn in glob.glob(os.path.join(pkgdatadir, 'shlibs2', '*.pclist')): + with open(fn, 'r') as f: + for line in f: + pkgmap[os.path.basename(line.rstrip())] = os.path.splitext(os.path.basename(fn))[0] + recipemap = {} + for pc, pkg in pkgmap.items(): + pkgdatafile = os.path.join(pkgdatadir, 'runtime', pkg) + if os.path.exists(pkgdatafile): + with open(pkgdatafile, 'r') as f: + for line in f: + if line.startswith('PN: '): + recipemap[pc] = line.split(':', 1)[1].strip() + return recipemap + +def convert_debian(debpath): + value_map = {'Package': 'PN', + 'Version': 'PV', + 'Section': 'SECTION', + 'License': 'LICENSE', + 'Homepage': 'HOMEPAGE'} + + # FIXME extend this mapping - perhaps use distro_alias.inc? + depmap = {'libz-dev': 'zlib'} + + values = {} + depends = [] + with open(os.path.join(debpath, 'control'), 'r', errors='surrogateescape') as f: + indesc = False + for line in f: + if indesc: + if line.startswith(' '): + if line.startswith(' This package contains'): + indesc = False + else: + if 'DESCRIPTION' in values: + values['DESCRIPTION'] += ' ' + line.strip() + else: + values['DESCRIPTION'] = line.strip() + else: + indesc = False + if not indesc: + splitline = line.split(':', 1) + if len(splitline) < 2: + continue + key = splitline[0] + value = splitline[1].strip() + if key == 'Build-Depends': + for dep in value.split(','): + dep = dep.split()[0] + mapped = depmap.get(dep, '') + if mapped: + depends.append(mapped) + elif key == 'Description': + values['SUMMARY'] = value + indesc = True + else: + varname = value_map.get(key, None) + if varname: + values[varname] = value + postinst = os.path.join(debpath, 'postinst') + postrm = os.path.join(debpath, 'postrm') + preinst = os.path.join(debpath, 'preinst') + prerm = os.path.join(debpath, 'prerm') + sfiles = [postinst, postrm, preinst, prerm] + for sfile in sfiles: + if os.path.isfile(sfile): + logger.info("Converting %s file to recipe function..." % + os.path.basename(sfile).upper()) + content = [] + with open(sfile) as f: + for line in f: + if "#!/" in line: + continue + line = line.rstrip("\n") + if line.strip(): + content.append(line) + if content: + values[os.path.basename(f.name)] = content + + #if depends: + # values['DEPENDS'] = ' '.join(depends) + + return values + +def convert_rpm_xml(xmlfile): + '''Converts the output from rpm -qp --xml to a set of variable values''' + import xml.etree.ElementTree as ElementTree + rpmtag_map = {'Name': 'PN', + 'Version': 'PV', + 'Summary': 'SUMMARY', + 'Description': 'DESCRIPTION', + 'License': 'LICENSE', + 'Url': 'HOMEPAGE'} + + values = {} + tree = ElementTree.parse(xmlfile) + root = tree.getroot() + for child in root: + if child.tag == 'rpmTag': + name = child.attrib.get('name', None) + if name: + varname = rpmtag_map.get(name, None) + if varname: + values[varname] = child[0].text + return values + + +def check_npm(tinfoil, debugonly=False): + try: + rd = tinfoil.parse_recipe('nodejs-native') + except bb.providers.NoProvider: + # We still conditionally show the message and exit with the special + # return code, otherwise we can't show the proper message for eSDK + # users + log_error_cond('nodejs-native is required for npm but is not available - you will likely need to add a layer that provides nodejs', debugonly) + sys.exit(14) + bindir = rd.getVar('STAGING_BINDIR_NATIVE') + npmpath = os.path.join(bindir, 'npm') + if not os.path.exists(npmpath): + log_error_cond('npm required to process specified source, but npm is not available - you need to run bitbake -c addto_recipe_sysroot nodejs-native first', debugonly) + sys.exit(14) + return bindir + +def register_commands(subparsers): + parser_create = subparsers.add_parser('create', + help='Create a new recipe', + description='Creates a new recipe from a source tree') + parser_create.add_argument('source', help='Path or URL to source') + parser_create.add_argument('-o', '--outfile', help='Specify filename for recipe to create') + parser_create.add_argument('-m', '--machine', help='Make recipe machine-specific as opposed to architecture-specific', action='store_true') + parser_create.add_argument('-x', '--extract-to', metavar='EXTRACTPATH', help='Assuming source is a URL, fetch it and extract it to the directory specified as %(metavar)s') + parser_create.add_argument('-N', '--name', help='Name to use within recipe (PN)') + parser_create.add_argument('-V', '--version', help='Version to use within recipe (PV)') + parser_create.add_argument('-b', '--binary', help='Treat the source tree as something that should be installed verbatim (no compilation, same directory structure)', action='store_true') + parser_create.add_argument('--also-native', help='Also add native variant (i.e. support building recipe for the build host as well as the target machine)', action='store_true') + parser_create.add_argument('--src-subdir', help='Specify subdirectory within source tree to use', metavar='SUBDIR') + parser_create.add_argument('-a', '--autorev', help='When fetching from a git repository, set SRCREV in the recipe to a floating revision instead of fixed', action="store_true") + parser_create.add_argument('--keep-temp', action="store_true", help='Keep temporary directory (for debugging)') + parser_create.add_argument('--fetch-dev', action="store_true", help='For npm, also fetch devDependencies') + parser_create.add_argument('--devtool', action="store_true", help=argparse.SUPPRESS) + # FIXME I really hate having to set parserecipes for this, but given we may need + # to call into npm (and we don't know in advance if we will or not) and in order + # to do so we need to know npm's recipe sysroot path, there's not much alternative + parser_create.set_defaults(func=create_recipe, parserecipes=True) + diff --git a/scripts/lib/recipetool/create_buildsys.py b/scripts/lib/recipetool/create_buildsys.py new file mode 100644 index 0000000000..e914e53aab --- /dev/null +++ b/scripts/lib/recipetool/create_buildsys.py @@ -0,0 +1,889 @@ +# Recipe creation tool - create command build system handlers +# +# Copyright (C) 2014-2016 Intel Corporation +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +import re +import logging +import glob +from recipetool.create import RecipeHandler, validate_pv + +logger = logging.getLogger('recipetool') + +tinfoil = None +plugins = None + +def plugin_init(pluginlist): + # Take a reference to the list so we can use it later + global plugins + plugins = pluginlist + +def tinfoil_init(instance): + global tinfoil + tinfoil = instance + + +class CmakeRecipeHandler(RecipeHandler): + def process(self, srctree, classes, lines_before, lines_after, handled, extravalues): + if 'buildsystem' in handled: + return False + + if RecipeHandler.checkfiles(srctree, ['CMakeLists.txt']): + classes.append('cmake') + values = CmakeRecipeHandler.extract_cmake_deps(lines_before, srctree, extravalues) + classes.extend(values.pop('inherit', '').split()) + for var, value in values.items(): + lines_before.append('%s = "%s"' % (var, value)) + lines_after.append('# Specify any options you want to pass to cmake using EXTRA_OECMAKE:') + lines_after.append('EXTRA_OECMAKE = ""') + lines_after.append('') + handled.append('buildsystem') + return True + return False + + @staticmethod + def extract_cmake_deps(outlines, srctree, extravalues, cmakelistsfile=None): + # Find all plugins that want to register handlers + logger.debug('Loading cmake handlers') + handlers = [] + for plugin in plugins: + if hasattr(plugin, 'register_cmake_handlers'): + plugin.register_cmake_handlers(handlers) + + values = {} + inherits = [] + + if cmakelistsfile: + srcfiles = [cmakelistsfile] + else: + srcfiles = RecipeHandler.checkfiles(srctree, ['CMakeLists.txt']) + + # Note that some of these are non-standard, but probably better to + # be able to map them anyway if we see them + cmake_pkgmap = {'alsa': 'alsa-lib', + 'aspell': 'aspell', + 'atk': 'atk', + 'bison': 'bison-native', + 'boost': 'boost', + 'bzip2': 'bzip2', + 'cairo': 'cairo', + 'cups': 'cups', + 'curl': 'curl', + 'curses': 'ncurses', + 'cvs': 'cvs', + 'drm': 'libdrm', + 'dbus': 'dbus', + 'dbusglib': 'dbus-glib', + 'egl': 'virtual/egl', + 'expat': 'expat', + 'flex': 'flex-native', + 'fontconfig': 'fontconfig', + 'freetype': 'freetype', + 'gettext': '', + 'git': '', + 'gio': 'glib-2.0', + 'giounix': 'glib-2.0', + 'glew': 'glew', + 'glib': 'glib-2.0', + 'glib2': 'glib-2.0', + 'glu': 'libglu', + 'glut': 'freeglut', + 'gobject': 'glib-2.0', + 'gperf': 'gperf-native', + 'gnutls': 'gnutls', + 'gtk2': 'gtk+', + 'gtk3': 'gtk+3', + 'gtk': 'gtk+3', + 'harfbuzz': 'harfbuzz', + 'icu': 'icu', + 'intl': 'virtual/libintl', + 'jpeg': 'jpeg', + 'libarchive': 'libarchive', + 'libiconv': 'virtual/libiconv', + 'liblzma': 'xz', + 'libxml2': 'libxml2', + 'libxslt': 'libxslt', + 'opengl': 'virtual/libgl', + 'openmp': '', + 'openssl': 'openssl', + 'pango': 'pango', + 'perl': '', + 'perllibs': '', + 'pkgconfig': '', + 'png': 'libpng', + 'pthread': '', + 'pythoninterp': '', + 'pythonlibs': '', + 'ruby': 'ruby-native', + 'sdl': 'libsdl', + 'sdl2': 'libsdl2', + 'subversion': 'subversion-native', + 'swig': 'swig-native', + 'tcl': 'tcl-native', + 'threads': '', + 'tiff': 'tiff', + 'wget': 'wget', + 'x11': 'libx11', + 'xcb': 'libxcb', + 'xext': 'libxext', + 'xfixes': 'libxfixes', + 'zlib': 'zlib', + } + + pcdeps = [] + libdeps = [] + deps = [] + unmappedpkgs = [] + + proj_re = re.compile('project\s*\(([^)]*)\)', re.IGNORECASE) + pkgcm_re = re.compile('pkg_check_modules\s*\(\s*[a-zA-Z0-9-_]+\s*(REQUIRED)?\s+([^)\s]+)\s*\)', re.IGNORECASE) + pkgsm_re = re.compile('pkg_search_module\s*\(\s*[a-zA-Z0-9-_]+\s*(REQUIRED)?((\s+[^)\s]+)+)\s*\)', re.IGNORECASE) + findpackage_re = re.compile('find_package\s*\(\s*([a-zA-Z0-9-_]+)\s*.*', re.IGNORECASE) + findlibrary_re = re.compile('find_library\s*\(\s*[a-zA-Z0-9-_]+\s*(NAMES\s+)?([a-zA-Z0-9-_ ]+)\s*.*') + checklib_re = re.compile('check_library_exists\s*\(\s*([^\s)]+)\s*.*', re.IGNORECASE) + include_re = re.compile('include\s*\(\s*([^)\s]*)\s*\)', re.IGNORECASE) + subdir_re = re.compile('add_subdirectory\s*\(\s*([^)\s]*)\s*([^)\s]*)\s*\)', re.IGNORECASE) + dep_re = re.compile('([^ ><=]+)( *[<>=]+ *[^ ><=]+)?') + + def find_cmake_package(pkg): + RecipeHandler.load_devel_filemap(tinfoil.config_data) + for fn, pn in RecipeHandler.recipecmakefilemap.items(): + splitname = fn.split('/') + if len(splitname) > 1: + if splitname[0].lower().startswith(pkg.lower()): + if splitname[1] == '%s-config.cmake' % pkg.lower() or splitname[1] == '%sConfig.cmake' % pkg or splitname[1] == 'Find%s.cmake' % pkg: + return pn + return None + + def interpret_value(value): + return value.strip('"') + + def parse_cmake_file(fn, paths=None): + searchpaths = (paths or []) + [os.path.dirname(fn)] + logger.debug('Parsing file %s' % fn) + with open(fn, 'r', errors='surrogateescape') as f: + for line in f: + line = line.strip() + for handler in handlers: + if handler.process_line(srctree, fn, line, libdeps, pcdeps, deps, outlines, inherits, values): + continue + res = include_re.match(line) + if res: + includefn = bb.utils.which(':'.join(searchpaths), res.group(1)) + if includefn: + parse_cmake_file(includefn, searchpaths) + else: + logger.debug('Unable to recurse into include file %s' % res.group(1)) + continue + res = subdir_re.match(line) + if res: + subdirfn = os.path.join(os.path.dirname(fn), res.group(1), 'CMakeLists.txt') + if os.path.exists(subdirfn): + parse_cmake_file(subdirfn, searchpaths) + else: + logger.debug('Unable to recurse into subdirectory file %s' % subdirfn) + continue + res = proj_re.match(line) + if res: + extravalues['PN'] = interpret_value(res.group(1).split()[0]) + continue + res = pkgcm_re.match(line) + if res: + res = dep_re.findall(res.group(2)) + if res: + pcdeps.extend([interpret_value(x[0]) for x in res]) + inherits.append('pkgconfig') + continue + res = pkgsm_re.match(line) + if res: + res = dep_re.findall(res.group(2)) + if res: + # Note: appending a tuple here! + item = tuple((interpret_value(x[0]) for x in res)) + if len(item) == 1: + item = item[0] + pcdeps.append(item) + inherits.append('pkgconfig') + continue + res = findpackage_re.match(line) + if res: + origpkg = res.group(1) + pkg = interpret_value(origpkg) + found = False + for handler in handlers: + if handler.process_findpackage(srctree, fn, pkg, deps, outlines, inherits, values): + logger.debug('Mapped CMake package %s via handler %s' % (pkg, handler.__class__.__name__)) + found = True + break + if found: + continue + elif pkg == 'Gettext': + inherits.append('gettext') + elif pkg == 'Perl': + inherits.append('perlnative') + elif pkg == 'PkgConfig': + inherits.append('pkgconfig') + elif pkg == 'PythonInterp': + inherits.append('pythonnative') + elif pkg == 'PythonLibs': + inherits.append('python-dir') + else: + # Try to map via looking at installed CMake packages in pkgdata + dep = find_cmake_package(pkg) + if dep: + logger.debug('Mapped CMake package %s to recipe %s via pkgdata' % (pkg, dep)) + deps.append(dep) + else: + dep = cmake_pkgmap.get(pkg.lower(), None) + if dep: + logger.debug('Mapped CMake package %s to recipe %s via internal list' % (pkg, dep)) + deps.append(dep) + elif dep is None: + unmappedpkgs.append(origpkg) + continue + res = checklib_re.match(line) + if res: + lib = interpret_value(res.group(1)) + if not lib.startswith('$'): + libdeps.append(lib) + res = findlibrary_re.match(line) + if res: + libs = res.group(2).split() + for lib in libs: + if lib in ['HINTS', 'PATHS', 'PATH_SUFFIXES', 'DOC', 'NAMES_PER_DIR'] or lib.startswith(('NO_', 'CMAKE_', 'ONLY_CMAKE_')): + break + lib = interpret_value(lib) + if not lib.startswith('$'): + libdeps.append(lib) + if line.lower().startswith('useswig'): + deps.append('swig-native') + continue + + parse_cmake_file(srcfiles[0]) + + if unmappedpkgs: + outlines.append('# NOTE: unable to map the following CMake package dependencies: %s' % ' '.join(list(set(unmappedpkgs)))) + + RecipeHandler.handle_depends(libdeps, pcdeps, deps, outlines, values, tinfoil.config_data) + + for handler in handlers: + handler.post_process(srctree, libdeps, pcdeps, deps, outlines, inherits, values) + + if inherits: + values['inherit'] = ' '.join(list(set(inherits))) + + return values + + +class CmakeExtensionHandler(object): + '''Base class for CMake extension handlers''' + def process_line(self, srctree, fn, line, libdeps, pcdeps, deps, outlines, inherits, values): + ''' + Handle a line parsed out of an CMake file. + Return True if you've completely handled the passed in line, otherwise return False. + ''' + return False + + def process_findpackage(self, srctree, fn, pkg, deps, outlines, inherits, values): + ''' + Handle a find_package package parsed out of a CMake file. + Return True if you've completely handled the passed in package, otherwise return False. + ''' + return False + + def post_process(self, srctree, fn, pkg, deps, outlines, inherits, values): + ''' + Apply any desired post-processing on the output + ''' + return + + + +class SconsRecipeHandler(RecipeHandler): + def process(self, srctree, classes, lines_before, lines_after, handled, extravalues): + if 'buildsystem' in handled: + return False + + if RecipeHandler.checkfiles(srctree, ['SConstruct', 'Sconstruct', 'sconstruct']): + classes.append('scons') + lines_after.append('# Specify any options you want to pass to scons using EXTRA_OESCONS:') + lines_after.append('EXTRA_OESCONS = ""') + lines_after.append('') + handled.append('buildsystem') + return True + return False + + +class QmakeRecipeHandler(RecipeHandler): + def process(self, srctree, classes, lines_before, lines_after, handled, extravalues): + if 'buildsystem' in handled: + return False + + if RecipeHandler.checkfiles(srctree, ['*.pro']): + classes.append('qmake2') + handled.append('buildsystem') + return True + return False + + +class AutotoolsRecipeHandler(RecipeHandler): + def process(self, srctree, classes, lines_before, lines_after, handled, extravalues): + if 'buildsystem' in handled: + return False + + autoconf = False + if RecipeHandler.checkfiles(srctree, ['configure.ac', 'configure.in']): + autoconf = True + values = AutotoolsRecipeHandler.extract_autotools_deps(lines_before, srctree, extravalues) + classes.extend(values.pop('inherit', '').split()) + for var, value in values.items(): + lines_before.append('%s = "%s"' % (var, value)) + else: + conffile = RecipeHandler.checkfiles(srctree, ['configure']) + if conffile: + # Check if this is just a pre-generated autoconf configure script + with open(conffile[0], 'r', errors='surrogateescape') as f: + for i in range(1, 10): + if 'Generated by GNU Autoconf' in f.readline(): + autoconf = True + break + + if autoconf and not ('PV' in extravalues and 'PN' in extravalues): + # Last resort + conffile = RecipeHandler.checkfiles(srctree, ['configure']) + if conffile: + with open(conffile[0], 'r', errors='surrogateescape') as f: + for line in f: + line = line.strip() + if line.startswith('VERSION=') or line.startswith('PACKAGE_VERSION='): + pv = line.split('=')[1].strip('"\'') + if pv and not 'PV' in extravalues and validate_pv(pv): + extravalues['PV'] = pv + elif line.startswith('PACKAGE_NAME=') or line.startswith('PACKAGE='): + pn = line.split('=')[1].strip('"\'') + if pn and not 'PN' in extravalues: + extravalues['PN'] = pn + + if autoconf: + lines_before.append('') + lines_before.append('# NOTE: if this software is not capable of being built in a separate build directory') + lines_before.append('# from the source, you should replace autotools with autotools-brokensep in the') + lines_before.append('# inherit line') + classes.append('autotools') + lines_after.append('# Specify any options you want to pass to the configure script using EXTRA_OECONF:') + lines_after.append('EXTRA_OECONF = ""') + lines_after.append('') + handled.append('buildsystem') + return True + + return False + + @staticmethod + def extract_autotools_deps(outlines, srctree, extravalues=None, acfile=None): + import shlex + + # Find all plugins that want to register handlers + logger.debug('Loading autotools handlers') + handlers = [] + for plugin in plugins: + if hasattr(plugin, 'register_autotools_handlers'): + plugin.register_autotools_handlers(handlers) + + values = {} + inherits = [] + + # Hardcoded map, we also use a dynamic one based on what's in the sysroot + progmap = {'flex': 'flex-native', + 'bison': 'bison-native', + 'm4': 'm4-native', + 'tar': 'tar-native', + 'ar': 'binutils-native', + 'ranlib': 'binutils-native', + 'ld': 'binutils-native', + 'strip': 'binutils-native', + 'libtool': '', + 'autoconf': '', + 'autoheader': '', + 'automake': '', + 'uname': '', + 'rm': '', + 'cp': '', + 'mv': '', + 'find': '', + 'awk': '', + 'sed': '', + } + progclassmap = {'gconftool-2': 'gconf', + 'pkg-config': 'pkgconfig', + 'python': 'pythonnative', + 'python3': 'python3native', + 'perl': 'perlnative', + 'makeinfo': 'texinfo', + } + + pkg_re = re.compile('PKG_CHECK_MODULES\(\s*\[?[a-zA-Z0-9_]*\]?,\s*\[?([^,\]]*)\]?[),].*') + pkgce_re = re.compile('PKG_CHECK_EXISTS\(\s*\[?([^,\]]*)\]?[),].*') + lib_re = re.compile('AC_CHECK_LIB\(\s*\[?([^,\]]*)\]?,.*') + libx_re = re.compile('AX_CHECK_LIBRARY\(\s*\[?[^,\]]*\]?,\s*\[?([^,\]]*)\]?,\s*\[?([a-zA-Z0-9-]*)\]?,.*') + progs_re = re.compile('_PROGS?\(\s*\[?[a-zA-Z0-9_]*\]?,\s*\[?([^,\]]*)\]?[),].*') + dep_re = re.compile('([^ ><=]+)( [<>=]+ [^ ><=]+)?') + ac_init_re = re.compile('AC_INIT\(\s*([^,]+),\s*([^,]+)[,)].*') + am_init_re = re.compile('AM_INIT_AUTOMAKE\(\s*([^,]+),\s*([^,]+)[,)].*') + define_re = re.compile('\s*(m4_)?define\(\s*([^,]+),\s*([^,]+)\)') + version_re = re.compile('([0-9.]+)') + + defines = {} + def subst_defines(value): + newvalue = value + for define, defval in defines.items(): + newvalue = newvalue.replace(define, defval) + if newvalue != value: + return subst_defines(newvalue) + return value + + def process_value(value): + value = value.replace('[', '').replace(']', '') + if value.startswith('m4_esyscmd(') or value.startswith('m4_esyscmd_s('): + cmd = subst_defines(value[value.index('(')+1:-1]) + try: + if '|' in cmd: + cmd = 'set -o pipefail; ' + cmd + stdout, _ = bb.process.run(cmd, cwd=srctree, shell=True) + ret = stdout.rstrip() + except bb.process.ExecutionError as e: + ret = '' + elif value.startswith('m4_'): + return None + ret = subst_defines(value) + if ret: + ret = ret.strip('"\'') + return ret + + # Since a configure.ac file is essentially a program, this is only ever going to be + # a hack unfortunately; but it ought to be enough of an approximation + if acfile: + srcfiles = [acfile] + else: + srcfiles = RecipeHandler.checkfiles(srctree, ['acinclude.m4', 'configure.ac', 'configure.in']) + + pcdeps = [] + libdeps = [] + deps = [] + unmapped = [] + + RecipeHandler.load_binmap(tinfoil.config_data) + + def process_macro(keyword, value): + for handler in handlers: + if handler.process_macro(srctree, keyword, value, process_value, libdeps, pcdeps, deps, outlines, inherits, values): + return + logger.debug('Found keyword %s with value "%s"' % (keyword, value)) + if keyword == 'PKG_CHECK_MODULES': + res = pkg_re.search(value) + if res: + res = dep_re.findall(res.group(1)) + if res: + pcdeps.extend([x[0] for x in res]) + inherits.append('pkgconfig') + elif keyword == 'PKG_CHECK_EXISTS': + res = pkgce_re.search(value) + if res: + res = dep_re.findall(res.group(1)) + if res: + pcdeps.extend([x[0] for x in res]) + inherits.append('pkgconfig') + elif keyword in ('AM_GNU_GETTEXT', 'AM_GLIB_GNU_GETTEXT', 'GETTEXT_PACKAGE'): + inherits.append('gettext') + elif keyword in ('AC_PROG_INTLTOOL', 'IT_PROG_INTLTOOL'): + deps.append('intltool-native') + elif keyword == 'AM_PATH_GLIB_2_0': + deps.append('glib-2.0') + elif keyword in ('AC_CHECK_PROG', 'AC_PATH_PROG', 'AX_WITH_PROG'): + res = progs_re.search(value) + if res: + for prog in shlex.split(res.group(1)): + prog = prog.split()[0] + for handler in handlers: + if handler.process_prog(srctree, keyword, value, prog, deps, outlines, inherits, values): + return + progclass = progclassmap.get(prog, None) + if progclass: + inherits.append(progclass) + else: + progdep = RecipeHandler.recipebinmap.get(prog, None) + if not progdep: + progdep = progmap.get(prog, None) + if progdep: + deps.append(progdep) + elif progdep is None: + if not prog.startswith('$'): + unmapped.append(prog) + elif keyword == 'AC_CHECK_LIB': + res = lib_re.search(value) + if res: + lib = res.group(1) + if not lib.startswith('$'): + libdeps.append(lib) + elif keyword == 'AX_CHECK_LIBRARY': + res = libx_re.search(value) + if res: + lib = res.group(2) + if not lib.startswith('$'): + header = res.group(1) + libdeps.append((lib, header)) + elif keyword == 'AC_PATH_X': + deps.append('libx11') + elif keyword in ('AX_BOOST', 'BOOST_REQUIRE'): + deps.append('boost') + elif keyword in ('AC_PROG_LEX', 'AM_PROG_LEX', 'AX_PROG_FLEX'): + deps.append('flex-native') + elif keyword in ('AC_PROG_YACC', 'AX_PROG_BISON'): + deps.append('bison-native') + elif keyword == 'AX_CHECK_ZLIB': + deps.append('zlib') + elif keyword in ('AX_CHECK_OPENSSL', 'AX_LIB_CRYPTO'): + deps.append('openssl') + elif keyword == 'AX_LIB_CURL': + deps.append('curl') + elif keyword == 'AX_LIB_BEECRYPT': + deps.append('beecrypt') + elif keyword == 'AX_LIB_EXPAT': + deps.append('expat') + elif keyword == 'AX_LIB_GCRYPT': + deps.append('libgcrypt') + elif keyword == 'AX_LIB_NETTLE': + deps.append('nettle') + elif keyword == 'AX_LIB_READLINE': + deps.append('readline') + elif keyword == 'AX_LIB_SQLITE3': + deps.append('sqlite3') + elif keyword == 'AX_LIB_TAGLIB': + deps.append('taglib') + elif keyword in ['AX_PKG_SWIG', 'AC_PROG_SWIG']: + deps.append('swig-native') + elif keyword == 'AX_PROG_XSLTPROC': + deps.append('libxslt-native') + elif keyword in ['AC_PYTHON_DEVEL', 'AX_PYTHON_DEVEL', 'AM_PATH_PYTHON']: + pythonclass = 'pythonnative' + res = version_re.search(value) + if res: + if res.group(1).startswith('3'): + pythonclass = 'python3native' + # Avoid replacing python3native with pythonnative + if not pythonclass in inherits and not 'python3native' in inherits: + if 'pythonnative' in inherits: + inherits.remove('pythonnative') + inherits.append(pythonclass) + elif keyword == 'AX_WITH_CURSES': + deps.append('ncurses') + elif keyword == 'AX_PATH_BDB': + deps.append('db') + elif keyword == 'AX_PATH_LIB_PCRE': + deps.append('libpcre') + elif keyword == 'AC_INIT': + if extravalues is not None: + res = ac_init_re.match(value) + if res: + extravalues['PN'] = process_value(res.group(1)) + pv = process_value(res.group(2)) + if validate_pv(pv): + extravalues['PV'] = pv + elif keyword == 'AM_INIT_AUTOMAKE': + if extravalues is not None: + if 'PN' not in extravalues: + res = am_init_re.match(value) + if res: + if res.group(1) != 'AC_PACKAGE_NAME': + extravalues['PN'] = process_value(res.group(1)) + pv = process_value(res.group(2)) + if validate_pv(pv): + extravalues['PV'] = pv + elif keyword == 'define(': + res = define_re.match(value) + if res: + key = res.group(2).strip('[]') + value = process_value(res.group(3)) + if value is not None: + defines[key] = value + + keywords = ['PKG_CHECK_MODULES', + 'PKG_CHECK_EXISTS', + 'AM_GNU_GETTEXT', + 'AM_GLIB_GNU_GETTEXT', + 'GETTEXT_PACKAGE', + 'AC_PROG_INTLTOOL', + 'IT_PROG_INTLTOOL', + 'AM_PATH_GLIB_2_0', + 'AC_CHECK_PROG', + 'AC_PATH_PROG', + 'AX_WITH_PROG', + 'AC_CHECK_LIB', + 'AX_CHECK_LIBRARY', + 'AC_PATH_X', + 'AX_BOOST', + 'BOOST_REQUIRE', + 'AC_PROG_LEX', + 'AM_PROG_LEX', + 'AX_PROG_FLEX', + 'AC_PROG_YACC', + 'AX_PROG_BISON', + 'AX_CHECK_ZLIB', + 'AX_CHECK_OPENSSL', + 'AX_LIB_CRYPTO', + 'AX_LIB_CURL', + 'AX_LIB_BEECRYPT', + 'AX_LIB_EXPAT', + 'AX_LIB_GCRYPT', + 'AX_LIB_NETTLE', + 'AX_LIB_READLINE' + 'AX_LIB_SQLITE3', + 'AX_LIB_TAGLIB', + 'AX_PKG_SWIG', + 'AC_PROG_SWIG', + 'AX_PROG_XSLTPROC', + 'AC_PYTHON_DEVEL', + 'AX_PYTHON_DEVEL', + 'AM_PATH_PYTHON', + 'AX_WITH_CURSES', + 'AX_PATH_BDB', + 'AX_PATH_LIB_PCRE', + 'AC_INIT', + 'AM_INIT_AUTOMAKE', + 'define(', + ] + + for handler in handlers: + handler.extend_keywords(keywords) + + for srcfile in srcfiles: + nesting = 0 + in_keyword = '' + partial = '' + with open(srcfile, 'r', errors='surrogateescape') as f: + for line in f: + if in_keyword: + partial += ' ' + line.strip() + if partial.endswith('\\'): + partial = partial[:-1] + nesting = nesting + line.count('(') - line.count(')') + if nesting == 0: + process_macro(in_keyword, partial) + partial = '' + in_keyword = '' + else: + for keyword in keywords: + if keyword in line: + nesting = line.count('(') - line.count(')') + if nesting > 0: + partial = line.strip() + if partial.endswith('\\'): + partial = partial[:-1] + in_keyword = keyword + else: + process_macro(keyword, line.strip()) + break + + if in_keyword: + process_macro(in_keyword, partial) + + if extravalues: + for k,v in list(extravalues.items()): + if v: + if v.startswith('$') or v.startswith('@') or v.startswith('%'): + del extravalues[k] + else: + extravalues[k] = v.strip('"\'').rstrip('()') + + if unmapped: + outlines.append('# NOTE: the following prog dependencies are unknown, ignoring: %s' % ' '.join(list(set(unmapped)))) + + RecipeHandler.handle_depends(libdeps, pcdeps, deps, outlines, values, tinfoil.config_data) + + for handler in handlers: + handler.post_process(srctree, libdeps, pcdeps, deps, outlines, inherits, values) + + if inherits: + values['inherit'] = ' '.join(list(set(inherits))) + + return values + + +class AutotoolsExtensionHandler(object): + '''Base class for Autotools extension handlers''' + def process_macro(self, srctree, keyword, value, process_value, libdeps, pcdeps, deps, outlines, inherits, values): + ''' + Handle a macro parsed out of an autotools file. Note that if you want this to be called + for any macro other than the ones AutotoolsRecipeHandler already looks for, you'll need + to add it to the keywords list in extend_keywords(). + Return True if you've completely handled the passed in macro, otherwise return False. + ''' + return False + + def extend_keywords(self, keywords): + '''Adds keywords to be recognised by the parser (so that you get a call to process_macro)''' + return + + def process_prog(self, srctree, keyword, value, prog, deps, outlines, inherits, values): + ''' + Handle an AC_PATH_PROG, AC_CHECK_PROG etc. line + Return True if you've completely handled the passed in macro, otherwise return False. + ''' + return False + + def post_process(self, srctree, fn, pkg, deps, outlines, inherits, values): + ''' + Apply any desired post-processing on the output + ''' + return + + +class MakefileRecipeHandler(RecipeHandler): + def process(self, srctree, classes, lines_before, lines_after, handled, extravalues): + if 'buildsystem' in handled: + return False + + makefile = RecipeHandler.checkfiles(srctree, ['Makefile', 'makefile', 'GNUmakefile']) + if makefile: + lines_after.append('# NOTE: this is a Makefile-only piece of software, so we cannot generate much of the') + lines_after.append('# recipe automatically - you will need to examine the Makefile yourself and ensure') + lines_after.append('# that the appropriate arguments are passed in.') + lines_after.append('') + + scanfile = os.path.join(srctree, 'configure.scan') + skipscan = False + try: + stdout, stderr = bb.process.run('autoscan', cwd=srctree, shell=True) + except bb.process.ExecutionError as e: + skipscan = True + if scanfile and os.path.exists(scanfile): + values = AutotoolsRecipeHandler.extract_autotools_deps(lines_before, srctree, acfile=scanfile) + classes.extend(values.pop('inherit', '').split()) + for var, value in values.items(): + if var == 'DEPENDS': + lines_before.append('# NOTE: some of these dependencies may be optional, check the Makefile and/or upstream documentation') + lines_before.append('%s = "%s"' % (var, value)) + lines_before.append('') + for f in ['configure.scan', 'autoscan.log']: + fp = os.path.join(srctree, f) + if os.path.exists(fp): + os.remove(fp) + + self.genfunction(lines_after, 'do_configure', ['# Specify any needed configure commands here']) + + func = [] + func.append('# You will almost certainly need to add additional arguments here') + func.append('oe_runmake') + self.genfunction(lines_after, 'do_compile', func) + + installtarget = True + try: + stdout, stderr = bb.process.run('make -n install', cwd=srctree, shell=True) + except bb.process.ExecutionError as e: + if e.exitcode != 1: + installtarget = False + func = [] + if installtarget: + func.append('# This is a guess; additional arguments may be required') + makeargs = '' + with open(makefile[0], 'r', errors='surrogateescape') as f: + for i in range(1, 100): + if 'DESTDIR' in f.readline(): + makeargs += " 'DESTDIR=${D}'" + break + func.append('oe_runmake install%s' % makeargs) + else: + func.append('# NOTE: unable to determine what to put here - there is a Makefile but no') + func.append('# target named "install", so you will need to define this yourself') + self.genfunction(lines_after, 'do_install', func) + + handled.append('buildsystem') + else: + lines_after.append('# NOTE: no Makefile found, unable to determine what needs to be done') + lines_after.append('') + self.genfunction(lines_after, 'do_configure', ['# Specify any needed configure commands here']) + self.genfunction(lines_after, 'do_compile', ['# Specify compilation commands here']) + self.genfunction(lines_after, 'do_install', ['# Specify install commands here']) + + +class VersionFileRecipeHandler(RecipeHandler): + def process(self, srctree, classes, lines_before, lines_after, handled, extravalues): + if 'PV' not in extravalues: + # Look for a VERSION or version file containing a single line consisting + # only of a version number + filelist = RecipeHandler.checkfiles(srctree, ['VERSION', 'version']) + version = None + for fileitem in filelist: + linecount = 0 + with open(fileitem, 'r', errors='surrogateescape') as f: + for line in f: + line = line.rstrip().strip('"\'') + linecount += 1 + if line: + if linecount > 1: + version = None + break + else: + if validate_pv(line): + version = line + if version: + extravalues['PV'] = version + break + + +class SpecFileRecipeHandler(RecipeHandler): + def process(self, srctree, classes, lines_before, lines_after, handled, extravalues): + if 'PV' in extravalues and 'PN' in extravalues: + return + filelist = RecipeHandler.checkfiles(srctree, ['*.spec'], recursive=True) + valuemap = {'Name': 'PN', + 'Version': 'PV', + 'Summary': 'SUMMARY', + 'Url': 'HOMEPAGE', + 'License': 'LICENSE'} + foundvalues = {} + for fileitem in filelist: + linecount = 0 + with open(fileitem, 'r', errors='surrogateescape') as f: + for line in f: + for value, varname in valuemap.items(): + if line.startswith(value + ':') and not varname in foundvalues: + foundvalues[varname] = line.split(':', 1)[1].strip() + break + if len(foundvalues) == len(valuemap): + break + if 'PV' in foundvalues: + if not validate_pv(foundvalues['PV']): + del foundvalues['PV'] + license = foundvalues.pop('LICENSE', None) + if license: + liccomment = '# NOTE: spec file indicates the license may be "%s"' % license + for i, line in enumerate(lines_before): + if line.startswith('LICENSE ='): + lines_before.insert(i, liccomment) + break + else: + lines_before.append(liccomment) + extravalues.update(foundvalues) + +def register_recipe_handlers(handlers): + # Set priorities with some gaps so that other plugins can insert + # their own handlers (so avoid changing these numbers) + handlers.append((CmakeRecipeHandler(), 50)) + handlers.append((AutotoolsRecipeHandler(), 40)) + handlers.append((SconsRecipeHandler(), 30)) + handlers.append((QmakeRecipeHandler(), 20)) + handlers.append((MakefileRecipeHandler(), 10)) + handlers.append((VersionFileRecipeHandler(), -1)) + handlers.append((SpecFileRecipeHandler(), -1)) diff --git a/scripts/lib/recipetool/create_buildsys_python.py b/scripts/lib/recipetool/create_buildsys_python.py new file mode 100644 index 0000000000..ec5449bee9 --- /dev/null +++ b/scripts/lib/recipetool/create_buildsys_python.py @@ -0,0 +1,717 @@ +# Recipe creation tool - create build system handler for python +# +# Copyright (C) 2015 Mentor Graphics Corporation +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +import ast +import codecs +import collections +import distutils.command.build_py +import email +import imp +import glob +import itertools +import logging +import os +import re +import sys +import subprocess +from recipetool.create import RecipeHandler + +logger = logging.getLogger('recipetool') + +tinfoil = None + + +def tinfoil_init(instance): + global tinfoil + tinfoil = instance + + +class PythonRecipeHandler(RecipeHandler): + base_pkgdeps = ['python-core'] + excluded_pkgdeps = ['python-dbg'] + # os.path is provided by python-core + assume_provided = ['builtins', 'os.path'] + # Assumes that the host python builtin_module_names is sane for target too + assume_provided = assume_provided + list(sys.builtin_module_names) + + bbvar_map = { + 'Name': 'PN', + 'Version': 'PV', + 'Home-page': 'HOMEPAGE', + 'Summary': 'SUMMARY', + 'Description': 'DESCRIPTION', + 'License': 'LICENSE', + 'Requires': 'RDEPENDS_${PN}', + 'Provides': 'RPROVIDES_${PN}', + 'Obsoletes': 'RREPLACES_${PN}', + } + # PN/PV are already set by recipetool core & desc can be extremely long + excluded_fields = [ + 'Description', + ] + setup_parse_map = { + 'Url': 'Home-page', + 'Classifiers': 'Classifier', + 'Description': 'Summary', + } + setuparg_map = { + 'Home-page': 'url', + 'Classifier': 'classifiers', + 'Summary': 'description', + 'Description': 'long-description', + } + # Values which are lists, used by the setup.py argument based metadata + # extraction method, to determine how to process the setup.py output. + setuparg_list_fields = [ + 'Classifier', + 'Requires', + 'Provides', + 'Obsoletes', + 'Platform', + 'Supported-Platform', + ] + setuparg_multi_line_values = ['Description'] + replacements = [ + ('License', r' +$', ''), + ('License', r'^ +', ''), + ('License', r' ', '-'), + ('License', r'^GNU-', ''), + ('License', r'-[Ll]icen[cs]e(,?-[Vv]ersion)?', ''), + ('License', r'^UNKNOWN$', ''), + + # Remove currently unhandled version numbers from these variables + ('Requires', r' *\([^)]*\)', ''), + ('Provides', r' *\([^)]*\)', ''), + ('Obsoletes', r' *\([^)]*\)', ''), + ('Install-requires', r'^([^><= ]+).*', r'\1'), + ('Extras-require', r'^([^><= ]+).*', r'\1'), + ('Tests-require', r'^([^><= ]+).*', r'\1'), + + # Remove unhandled dependency on particular features (e.g. foo[PDF]) + ('Install-requires', r'\[[^\]]+\]$', ''), + ] + + classifier_license_map = { + 'License :: OSI Approved :: Academic Free License (AFL)': 'AFL', + 'License :: OSI Approved :: Apache Software License': 'Apache', + 'License :: OSI Approved :: Apple Public Source License': 'APSL', + 'License :: OSI Approved :: Artistic License': 'Artistic', + 'License :: OSI Approved :: Attribution Assurance License': 'AAL', + 'License :: OSI Approved :: BSD License': 'BSD', + 'License :: OSI Approved :: Common Public License': 'CPL', + 'License :: OSI Approved :: Eiffel Forum License': 'EFL', + 'License :: OSI Approved :: European Union Public Licence 1.0 (EUPL 1.0)': 'EUPL-1.0', + 'License :: OSI Approved :: European Union Public Licence 1.1 (EUPL 1.1)': 'EUPL-1.1', + 'License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)': 'AGPL-3.0+', + 'License :: OSI Approved :: GNU Affero General Public License v3': 'AGPL-3.0', + 'License :: OSI Approved :: GNU Free Documentation License (FDL)': 'GFDL', + 'License :: OSI Approved :: GNU General Public License (GPL)': 'GPL', + 'License :: OSI Approved :: GNU General Public License v2 (GPLv2)': 'GPL-2.0', + 'License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)': 'GPL-2.0+', + 'License :: OSI Approved :: GNU General Public License v3 (GPLv3)': 'GPL-3.0', + 'License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)': 'GPL-3.0+', + 'License :: OSI Approved :: GNU Lesser General Public License v2 (LGPLv2)': 'LGPL-2.0', + 'License :: OSI Approved :: GNU Lesser General Public License v2 or later (LGPLv2+)': 'LGPL-2.0+', + 'License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)': 'LGPL-3.0', + 'License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)': 'LGPL-3.0+', + 'License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)': 'LGPL', + 'License :: OSI Approved :: IBM Public License': 'IPL', + 'License :: OSI Approved :: ISC License (ISCL)': 'ISC', + 'License :: OSI Approved :: Intel Open Source License': 'Intel', + 'License :: OSI Approved :: Jabber Open Source License': 'Jabber', + 'License :: OSI Approved :: MIT License': 'MIT', + 'License :: OSI Approved :: MITRE Collaborative Virtual Workspace License (CVW)': 'CVWL', + 'License :: OSI Approved :: Motosoto License': 'Motosoto', + 'License :: OSI Approved :: Mozilla Public License 1.0 (MPL)': 'MPL-1.0', + 'License :: OSI Approved :: Mozilla Public License 1.1 (MPL 1.1)': 'MPL-1.1', + 'License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)': 'MPL-2.0', + 'License :: OSI Approved :: Nethack General Public License': 'NGPL', + 'License :: OSI Approved :: Nokia Open Source License': 'Nokia', + 'License :: OSI Approved :: Open Group Test Suite License': 'OGTSL', + 'License :: OSI Approved :: Python License (CNRI Python License)': 'CNRI-Python', + 'License :: OSI Approved :: Python Software Foundation License': 'PSF', + 'License :: OSI Approved :: Qt Public License (QPL)': 'QPL', + 'License :: OSI Approved :: Ricoh Source Code Public License': 'RSCPL', + 'License :: OSI Approved :: Sleepycat License': 'Sleepycat', + 'License :: OSI Approved :: Sun Industry Standards Source License (SISSL)': '-- Sun Industry Standards Source License (SISSL)', + 'License :: OSI Approved :: Sun Public License': 'SPL', + 'License :: OSI Approved :: University of Illinois/NCSA Open Source License': 'NCSA', + 'License :: OSI Approved :: Vovida Software License 1.0': 'VSL-1.0', + 'License :: OSI Approved :: W3C License': 'W3C', + 'License :: OSI Approved :: X.Net License': 'Xnet', + 'License :: OSI Approved :: Zope Public License': 'ZPL', + 'License :: OSI Approved :: zlib/libpng License': 'Zlib', + } + + def __init__(self): + pass + + def process(self, srctree, classes, lines_before, lines_after, handled, extravalues): + if 'buildsystem' in handled: + return False + + if not RecipeHandler.checkfiles(srctree, ['setup.py']): + return + + # setup.py is always parsed to get at certain required information, such as + # distutils vs setuptools + # + # If egg info is available, we use it for both its PKG-INFO metadata + # and for its requires.txt for install_requires. + # If PKG-INFO is available but no egg info is, we use that for metadata in preference to + # the parsed setup.py, but use the install_requires info from the + # parsed setup.py. + + setupscript = os.path.join(srctree, 'setup.py') + try: + setup_info, uses_setuptools, setup_non_literals, extensions = self.parse_setup_py(setupscript) + except Exception: + logger.exception("Failed to parse setup.py") + setup_info, uses_setuptools, setup_non_literals, extensions = {}, True, [], [] + + egginfo = glob.glob(os.path.join(srctree, '*.egg-info')) + if egginfo: + info = self.get_pkginfo(os.path.join(egginfo[0], 'PKG-INFO')) + requires_txt = os.path.join(egginfo[0], 'requires.txt') + if os.path.exists(requires_txt): + with codecs.open(requires_txt) as f: + inst_req = [] + extras_req = collections.defaultdict(list) + current_feature = None + for line in f.readlines(): + line = line.rstrip() + if not line: + continue + + if line.startswith('['): + current_feature = line[1:-1] + elif current_feature: + extras_req[current_feature].append(line) + else: + inst_req.append(line) + info['Install-requires'] = inst_req + info['Extras-require'] = extras_req + elif RecipeHandler.checkfiles(srctree, ['PKG-INFO']): + info = self.get_pkginfo(os.path.join(srctree, 'PKG-INFO')) + + if setup_info: + if 'Install-requires' in setup_info: + info['Install-requires'] = setup_info['Install-requires'] + if 'Extras-require' in setup_info: + info['Extras-require'] = setup_info['Extras-require'] + else: + if setup_info: + info = setup_info + else: + info = self.get_setup_args_info(setupscript) + + # Grab the license value before applying replacements + license_str = info.get('License', '').strip() + + self.apply_info_replacements(info) + + if uses_setuptools: + classes.append('setuptools') + else: + classes.append('distutils') + + if license_str: + for i, line in enumerate(lines_before): + if line.startswith('LICENSE = '): + lines_before.insert(i, '# NOTE: License in setup.py/PKGINFO is: %s' % license_str) + break + + if 'Classifier' in info: + existing_licenses = info.get('License', '') + licenses = [] + for classifier in info['Classifier']: + if classifier in self.classifier_license_map: + license = self.classifier_license_map[classifier] + if license == 'Apache' and 'Apache-2.0' in existing_licenses: + license = 'Apache-2.0' + elif license == 'GPL': + if 'GPL-2.0' in existing_licenses or 'GPLv2' in existing_licenses: + license = 'GPL-2.0' + elif 'GPL-3.0' in existing_licenses or 'GPLv3' in existing_licenses: + license = 'GPL-3.0' + elif license == 'LGPL': + if 'LGPL-2.1' in existing_licenses or 'LGPLv2.1' in existing_licenses: + license = 'LGPL-2.1' + elif 'LGPL-2.0' in existing_licenses or 'LGPLv2' in existing_licenses: + license = 'LGPL-2.0' + elif 'LGPL-3.0' in existing_licenses or 'LGPLv3' in existing_licenses: + license = 'LGPL-3.0' + licenses.append(license) + + if licenses: + info['License'] = ' & '.join(licenses) + + # Map PKG-INFO & setup.py fields to bitbake variables + for field, values in info.items(): + if field in self.excluded_fields: + continue + + if field not in self.bbvar_map: + continue + + if isinstance(values, str): + value = values + else: + value = ' '.join(str(v) for v in values if v) + + bbvar = self.bbvar_map[field] + if bbvar not in extravalues and value: + extravalues[bbvar] = value + + mapped_deps, unmapped_deps = self.scan_setup_python_deps(srctree, setup_info, setup_non_literals) + + extras_req = set() + if 'Extras-require' in info: + extras_req = info['Extras-require'] + if extras_req: + lines_after.append('# The following configs & dependencies are from setuptools extras_require.') + lines_after.append('# These dependencies are optional, hence can be controlled via PACKAGECONFIG.') + lines_after.append('# The upstream names may not correspond exactly to bitbake package names.') + lines_after.append('#') + lines_after.append('# Uncomment this line to enable all the optional features.') + lines_after.append('#PACKAGECONFIG ?= "{}"'.format(' '.join(k.lower() for k in extras_req))) + for feature, feature_reqs in extras_req.items(): + unmapped_deps.difference_update(feature_reqs) + + feature_req_deps = ('python-' + r.replace('.', '-').lower() for r in sorted(feature_reqs)) + lines_after.append('PACKAGECONFIG[{}] = ",,,{}"'.format(feature.lower(), ' '.join(feature_req_deps))) + + inst_reqs = set() + if 'Install-requires' in info: + if extras_req: + lines_after.append('') + inst_reqs = info['Install-requires'] + if inst_reqs: + unmapped_deps.difference_update(inst_reqs) + + inst_req_deps = ('python-' + r.replace('.', '-').lower() for r in sorted(inst_reqs)) + lines_after.append('# WARNING: the following rdepends are from setuptools install_requires. These') + lines_after.append('# upstream names may not correspond exactly to bitbake package names.') + lines_after.append('RDEPENDS_${{PN}} += "{}"'.format(' '.join(inst_req_deps))) + + if mapped_deps: + name = info.get('Name') + if name and name[0] in mapped_deps: + # Attempt to avoid self-reference + mapped_deps.remove(name[0]) + mapped_deps -= set(self.excluded_pkgdeps) + if inst_reqs or extras_req: + lines_after.append('') + lines_after.append('# WARNING: the following rdepends are determined through basic analysis of the') + lines_after.append('# python sources, and might not be 100% accurate.') + lines_after.append('RDEPENDS_${{PN}} += "{}"'.format(' '.join(sorted(mapped_deps)))) + + unmapped_deps -= set(extensions) + unmapped_deps -= set(self.assume_provided) + if unmapped_deps: + if mapped_deps: + lines_after.append('') + lines_after.append('# WARNING: We were unable to map the following python package/module') + lines_after.append('# dependencies to the bitbake packages which include them:') + lines_after.extend('# {}'.format(d) for d in sorted(unmapped_deps)) + + handled.append('buildsystem') + + def get_pkginfo(self, pkginfo_fn): + msg = email.message_from_file(open(pkginfo_fn, 'r')) + msginfo = {} + for field in msg.keys(): + values = msg.get_all(field) + if len(values) == 1: + msginfo[field] = values[0] + else: + msginfo[field] = values + return msginfo + + def parse_setup_py(self, setupscript='./setup.py'): + with codecs.open(setupscript) as f: + info, imported_modules, non_literals, extensions = gather_setup_info(f) + + def _map(key): + key = key.replace('_', '-') + key = key[0].upper() + key[1:] + if key in self.setup_parse_map: + key = self.setup_parse_map[key] + return key + + # Naive mapping of setup() arguments to PKG-INFO field names + for d in [info, non_literals]: + for key, value in list(d.items()): + new_key = _map(key) + if new_key != key: + del d[key] + d[new_key] = value + + return info, 'setuptools' in imported_modules, non_literals, extensions + + def get_setup_args_info(self, setupscript='./setup.py'): + cmd = ['python', setupscript] + info = {} + keys = set(self.bbvar_map.keys()) + keys |= set(self.setuparg_list_fields) + keys |= set(self.setuparg_multi_line_values) + grouped_keys = itertools.groupby(keys, lambda k: (k in self.setuparg_list_fields, k in self.setuparg_multi_line_values)) + for index, keys in grouped_keys: + if index == (True, False): + # Splitlines output for each arg as a list value + for key in keys: + arg = self.setuparg_map.get(key, key.lower()) + try: + arg_info = self.run_command(cmd + ['--' + arg], cwd=os.path.dirname(setupscript)) + except (OSError, subprocess.CalledProcessError): + pass + else: + info[key] = [l.rstrip() for l in arg_info.splitlines()] + elif index == (False, True): + # Entire output for each arg + for key in keys: + arg = self.setuparg_map.get(key, key.lower()) + try: + arg_info = self.run_command(cmd + ['--' + arg], cwd=os.path.dirname(setupscript)) + except (OSError, subprocess.CalledProcessError): + pass + else: + info[key] = arg_info + else: + info.update(self.get_setup_byline(list(keys), setupscript)) + return info + + def get_setup_byline(self, fields, setupscript='./setup.py'): + info = {} + + cmd = ['python', setupscript] + cmd.extend('--' + self.setuparg_map.get(f, f.lower()) for f in fields) + try: + info_lines = self.run_command(cmd, cwd=os.path.dirname(setupscript)).splitlines() + except (OSError, subprocess.CalledProcessError): + pass + else: + if len(fields) != len(info_lines): + logger.error('Mismatch between setup.py output lines and number of fields') + sys.exit(1) + + for lineno, line in enumerate(info_lines): + line = line.rstrip() + info[fields[lineno]] = line + return info + + def apply_info_replacements(self, info): + for variable, search, replace in self.replacements: + if variable not in info: + continue + + def replace_value(search, replace, value): + if replace is None: + if re.search(search, value): + return None + else: + new_value = re.sub(search, replace, value) + if value != new_value: + return new_value + return value + + value = info[variable] + if isinstance(value, str): + new_value = replace_value(search, replace, value) + if new_value is None: + del info[variable] + elif new_value != value: + info[variable] = new_value + elif hasattr(value, 'items'): + for dkey, dvalue in list(value.items()): + new_list = [] + for pos, a_value in enumerate(dvalue): + new_value = replace_value(search, replace, a_value) + if new_value is not None and new_value != value: + new_list.append(new_value) + + if value != new_list: + value[dkey] = new_list + else: + new_list = [] + for pos, a_value in enumerate(value): + new_value = replace_value(search, replace, a_value) + if new_value is not None and new_value != value: + new_list.append(new_value) + + if value != new_list: + info[variable] = new_list + + def scan_setup_python_deps(self, srctree, setup_info, setup_non_literals): + if 'Package-dir' in setup_info: + package_dir = setup_info['Package-dir'] + else: + package_dir = {} + + class PackageDir(distutils.command.build_py.build_py): + def __init__(self, package_dir): + self.package_dir = package_dir + + pd = PackageDir(package_dir) + to_scan = [] + if not any(v in setup_non_literals for v in ['Py-modules', 'Scripts', 'Packages']): + if 'Py-modules' in setup_info: + for module in setup_info['Py-modules']: + try: + package, module = module.rsplit('.', 1) + except ValueError: + package, module = '.', module + module_path = os.path.join(pd.get_package_dir(package), module + '.py') + to_scan.append(module_path) + + if 'Packages' in setup_info: + for package in setup_info['Packages']: + to_scan.append(pd.get_package_dir(package)) + + if 'Scripts' in setup_info: + to_scan.extend(setup_info['Scripts']) + else: + logger.info("Scanning the entire source tree, as one or more of the following setup keywords are non-literal: py_modules, scripts, packages.") + + if not to_scan: + to_scan = ['.'] + + logger.info("Scanning paths for packages & dependencies: %s", ', '.join(to_scan)) + + provided_packages = self.parse_pkgdata_for_python_packages() + scanned_deps = self.scan_python_dependencies([os.path.join(srctree, p) for p in to_scan]) + mapped_deps, unmapped_deps = set(self.base_pkgdeps), set() + for dep in scanned_deps: + mapped = provided_packages.get(dep) + if mapped: + logger.debug('Mapped %s to %s' % (dep, mapped)) + mapped_deps.add(mapped) + else: + logger.debug('Could not map %s' % dep) + unmapped_deps.add(dep) + return mapped_deps, unmapped_deps + + def scan_python_dependencies(self, paths): + deps = set() + try: + dep_output = self.run_command(['pythondeps', '-d'] + paths) + except (OSError, subprocess.CalledProcessError): + pass + else: + for line in dep_output.splitlines(): + line = line.rstrip() + dep, filename = line.split('\t', 1) + if filename.endswith('/setup.py'): + continue + deps.add(dep) + + try: + provides_output = self.run_command(['pythondeps', '-p'] + paths) + except (OSError, subprocess.CalledProcessError): + pass + else: + provides_lines = (l.rstrip() for l in provides_output.splitlines()) + provides = set(l for l in provides_lines if l and l != 'setup') + deps -= provides + + return deps + + def parse_pkgdata_for_python_packages(self): + suffixes = [t[0] for t in imp.get_suffixes()] + pkgdata_dir = tinfoil.config_data.getVar('PKGDATA_DIR') + + ldata = tinfoil.config_data.createCopy() + bb.parse.handle('classes/python-dir.bbclass', ldata, True) + python_sitedir = ldata.getVar('PYTHON_SITEPACKAGES_DIR') + + dynload_dir = os.path.join(os.path.dirname(python_sitedir), 'lib-dynload') + python_dirs = [python_sitedir + os.sep, + os.path.join(os.path.dirname(python_sitedir), 'dist-packages') + os.sep, + os.path.dirname(python_sitedir) + os.sep] + packages = {} + for pkgdatafile in glob.glob('{}/runtime/*'.format(pkgdata_dir)): + files_info = None + with open(pkgdatafile, 'r') as f: + for line in f.readlines(): + field, value = line.split(': ', 1) + if field == 'FILES_INFO': + files_info = ast.literal_eval(value) + break + else: + continue + + for fn in files_info: + for suffix in suffixes: + if fn.endswith(suffix): + break + else: + continue + + if fn.startswith(dynload_dir + os.sep): + if '/.debug/' in fn: + continue + base = os.path.basename(fn) + provided = base.split('.', 1)[0] + packages[provided] = os.path.basename(pkgdatafile) + continue + + for python_dir in python_dirs: + if fn.startswith(python_dir): + relpath = fn[len(python_dir):] + relstart, _, relremaining = relpath.partition(os.sep) + if relstart.endswith('.egg'): + relpath = relremaining + base, _ = os.path.splitext(relpath) + + if '/.debug/' in base: + continue + if os.path.basename(base) == '__init__': + base = os.path.dirname(base) + base = base.replace(os.sep + os.sep, os.sep) + provided = base.replace(os.sep, '.') + packages[provided] = os.path.basename(pkgdatafile) + return packages + + @classmethod + def run_command(cls, cmd, **popenargs): + if 'stderr' not in popenargs: + popenargs['stderr'] = subprocess.STDOUT + try: + return subprocess.check_output(cmd, **popenargs).decode('utf-8') + except OSError as exc: + logger.error('Unable to run `{}`: {}', ' '.join(cmd), exc) + raise + except subprocess.CalledProcessError as exc: + logger.error('Unable to run `{}`: {}', ' '.join(cmd), exc.output) + raise + + +def gather_setup_info(fileobj): + parsed = ast.parse(fileobj.read(), fileobj.name) + visitor = SetupScriptVisitor() + visitor.visit(parsed) + + non_literals, extensions = {}, [] + for key, value in list(visitor.keywords.items()): + if key == 'ext_modules': + if isinstance(value, list): + for ext in value: + if (isinstance(ext, ast.Call) and + isinstance(ext.func, ast.Name) and + ext.func.id == 'Extension' and + not has_non_literals(ext.args)): + extensions.append(ext.args[0]) + elif has_non_literals(value): + non_literals[key] = value + del visitor.keywords[key] + + return visitor.keywords, visitor.imported_modules, non_literals, extensions + + +class SetupScriptVisitor(ast.NodeVisitor): + def __init__(self): + ast.NodeVisitor.__init__(self) + self.keywords = {} + self.non_literals = [] + self.imported_modules = set() + + def visit_Expr(self, node): + if isinstance(node.value, ast.Call) and \ + isinstance(node.value.func, ast.Name) and \ + node.value.func.id == 'setup': + self.visit_setup(node.value) + + def visit_setup(self, node): + call = LiteralAstTransform().visit(node) + self.keywords = call.keywords + for k, v in self.keywords.items(): + if has_non_literals(v): + self.non_literals.append(k) + + def visit_Import(self, node): + for alias in node.names: + self.imported_modules.add(alias.name) + + def visit_ImportFrom(self, node): + self.imported_modules.add(node.module) + + +class LiteralAstTransform(ast.NodeTransformer): + """Simplify the ast through evaluation of literals.""" + excluded_fields = ['ctx'] + + def visit(self, node): + if not isinstance(node, ast.AST): + return node + else: + return ast.NodeTransformer.visit(self, node) + + def generic_visit(self, node): + try: + return ast.literal_eval(node) + except ValueError: + for field, value in ast.iter_fields(node): + if field in self.excluded_fields: + delattr(node, field) + if value is None: + continue + + if isinstance(value, list): + if field in ('keywords', 'kwargs'): + new_value = dict((kw.arg, self.visit(kw.value)) for kw in value) + else: + new_value = [self.visit(i) for i in value] + else: + new_value = self.visit(value) + setattr(node, field, new_value) + return node + + def visit_Name(self, node): + if hasattr('__builtins__', node.id): + return getattr(__builtins__, node.id) + else: + return self.generic_visit(node) + + def visit_Tuple(self, node): + return tuple(self.visit(v) for v in node.elts) + + def visit_List(self, node): + return [self.visit(v) for v in node.elts] + + def visit_Set(self, node): + return set(self.visit(v) for v in node.elts) + + def visit_Dict(self, node): + keys = (self.visit(k) for k in node.keys) + values = (self.visit(v) for v in node.values) + return dict(zip(keys, values)) + + +def has_non_literals(value): + if isinstance(value, ast.AST): + return True + elif isinstance(value, str): + return False + elif hasattr(value, 'values'): + return any(has_non_literals(v) for v in value.values()) + elif hasattr(value, '__iter__'): + return any(has_non_literals(v) for v in value) + + +def register_recipe_handlers(handlers): + # We need to make sure this is ahead of the makefile fallback handler + handlers.append((PythonRecipeHandler(), 70)) diff --git a/scripts/lib/recipetool/create_kernel.py b/scripts/lib/recipetool/create_kernel.py new file mode 100644 index 0000000000..ca4996c7ac --- /dev/null +++ b/scripts/lib/recipetool/create_kernel.py @@ -0,0 +1,99 @@ +# Recipe creation tool - kernel support plugin +# +# Copyright (C) 2016 Intel Corporation +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +import re +import logging +from recipetool.create import RecipeHandler, read_pkgconfig_provides, validate_pv + +logger = logging.getLogger('recipetool') + +tinfoil = None + +def tinfoil_init(instance): + global tinfoil + tinfoil = instance + + +class KernelRecipeHandler(RecipeHandler): + def process(self, srctree, classes, lines_before, lines_after, handled, extravalues): + import bb.process + if 'buildsystem' in handled: + return False + + for tell in ['arch', 'firmware', 'Kbuild', 'Kconfig']: + if not os.path.exists(os.path.join(srctree, tell)): + return False + + handled.append('buildsystem') + del lines_after[:] + del classes[:] + template = os.path.join(tinfoil.config_data.getVar('COREBASE'), 'meta-skeleton', 'recipes-kernel', 'linux', 'linux-yocto-custom.bb') + def handle_var(varname, origvalue, op, newlines): + if varname in ['SRCREV', 'SRCREV_machine']: + while newlines[-1].startswith('#'): + del newlines[-1] + try: + stdout, _ = bb.process.run('git rev-parse HEAD', cwd=srctree, shell=True) + except bb.process.ExecutionError as e: + stdout = None + if stdout: + return stdout.strip(), op, 0, True + elif varname == 'LINUX_VERSION': + makefile = os.path.join(srctree, 'Makefile') + if os.path.exists(makefile): + kversion = -1 + kpatchlevel = -1 + ksublevel = -1 + kextraversion = '' + with open(makefile, 'r', errors='surrogateescape') as f: + for i, line in enumerate(f): + if i > 10: + break + if line.startswith('VERSION ='): + kversion = int(line.split('=')[1].strip()) + elif line.startswith('PATCHLEVEL ='): + kpatchlevel = int(line.split('=')[1].strip()) + elif line.startswith('SUBLEVEL ='): + ksublevel = int(line.split('=')[1].strip()) + elif line.startswith('EXTRAVERSION ='): + kextraversion = line.split('=')[1].strip() + version = '' + if kversion > -1 and kpatchlevel > -1: + version = '%d.%d' % (kversion, kpatchlevel) + if ksublevel > -1: + version += '.%d' % ksublevel + version += kextraversion + if version: + return version, op, 0, True + elif varname == 'SRC_URI': + while newlines[-1].startswith('#'): + del newlines[-1] + elif varname == 'COMPATIBLE_MACHINE': + while newlines[-1].startswith('#'): + del newlines[-1] + machine = tinfoil.config_data.getVar('MACHINE') + return machine, op, 0, True + return origvalue, op, 0, True + with open(template, 'r') as f: + varlist = ['SRCREV', 'SRCREV_machine', 'SRC_URI', 'LINUX_VERSION', 'COMPATIBLE_MACHINE'] + (_, newlines) = bb.utils.edit_metadata(f, varlist, handle_var) + lines_before[:] = [line.rstrip('\n') for line in newlines] + + return True + +def register_recipe_handlers(handlers): + handlers.append((KernelRecipeHandler(), 100)) diff --git a/scripts/lib/recipetool/create_kmod.py b/scripts/lib/recipetool/create_kmod.py new file mode 100644 index 0000000000..7cf188db21 --- /dev/null +++ b/scripts/lib/recipetool/create_kmod.py @@ -0,0 +1,152 @@ +# Recipe creation tool - kernel module support plugin +# +# Copyright (C) 2016 Intel Corporation +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +import re +import logging +from recipetool.create import RecipeHandler, read_pkgconfig_provides, validate_pv + +logger = logging.getLogger('recipetool') + +tinfoil = None + +def tinfoil_init(instance): + global tinfoil + tinfoil = instance + + +class KernelModuleRecipeHandler(RecipeHandler): + def process(self, srctree, classes, lines_before, lines_after, handled, extravalues): + import bb.process + if 'buildsystem' in handled: + return False + + module_inc_re = re.compile(r'^#include\s+<linux/module.h>$') + makefiles = [] + is_module = False + + makefiles = [] + + files = RecipeHandler.checkfiles(srctree, ['*.c', '*.h'], recursive=True) + if files: + for cfile in files: + # Look in same dir or parent for Makefile + for makefile in [os.path.join(os.path.dirname(cfile), 'Makefile'), os.path.join(os.path.dirname(os.path.dirname(cfile)), 'Makefile')]: + if makefile in makefiles: + break + else: + if os.path.exists(makefile): + makefiles.append(makefile) + break + else: + continue + with open(cfile, 'r', errors='surrogateescape') as f: + for line in f: + if module_inc_re.match(line.strip()): + is_module = True + break + if is_module: + break + + if is_module: + classes.append('module') + handled.append('buildsystem') + # module.bbclass and the classes it inherits do most of the hard + # work, but we need to tweak it slightly depending on what the + # Makefile does (and there is a range of those) + # Check the makefile for the appropriate install target + install_lines = [] + compile_lines = [] + in_install = False + in_compile = False + install_target = None + with open(makefile, 'r', errors='surrogateescape') as f: + for line in f: + if line.startswith('install:'): + if not install_lines: + in_install = True + install_target = 'install' + elif line.startswith('modules_install:'): + install_lines = [] + in_install = True + install_target = 'modules_install' + elif line.startswith('modules:'): + compile_lines = [] + in_compile = True + elif line.startswith(('all:', 'default:')): + if not compile_lines: + in_compile = True + elif line: + if line[0] == '\t': + if in_install: + install_lines.append(line) + elif in_compile: + compile_lines.append(line) + elif ':' in line: + in_install = False + in_compile = False + + def check_target(lines, install): + kdirpath = '' + manual_install = False + for line in lines: + splitline = line.split() + if splitline[0] in ['make', 'gmake', '$(MAKE)']: + if '-C' in splitline: + idx = splitline.index('-C') + 1 + if idx < len(splitline): + kdirpath = splitline[idx] + break + elif install and splitline[0] == 'install': + if '.ko' in line: + manual_install = True + return kdirpath, manual_install + + kdirpath = None + manual_install = False + if install_lines: + kdirpath, manual_install = check_target(install_lines, install=True) + if compile_lines and not kdirpath: + kdirpath, _ = check_target(compile_lines, install=False) + + if manual_install or not install_lines: + lines_after.append('EXTRA_OEMAKE_append_task-install = " -C ${STAGING_KERNEL_DIR} M=${S}"') + elif install_target and install_target != 'modules_install': + lines_after.append('MODULES_INSTALL_TARGET = "install"') + + warnmsg = None + kdirvar = None + if kdirpath: + res = re.match(r'\$\(([^$)]+)\)', kdirpath) + if res: + kdirvar = res.group(1) + if kdirvar != 'KERNEL_SRC': + lines_after.append('EXTRA_OEMAKE += "%s=${STAGING_KERNEL_DIR}"' % kdirvar) + elif kdirpath.startswith('/lib/'): + warnmsg = 'Kernel path in install makefile is hardcoded - you will need to patch the makefile' + if not kdirvar and not warnmsg: + warnmsg = 'Unable to find means of passing kernel path into install makefile - if kernel path is hardcoded you will need to patch the makefile' + if warnmsg: + warnmsg += '. Note that the variable KERNEL_SRC will be passed in as the kernel source path.' + logger.warn(warnmsg) + lines_after.append('# %s' % warnmsg) + + return True + + return False + +def register_recipe_handlers(handlers): + handlers.append((KernelModuleRecipeHandler(), 15)) diff --git a/scripts/lib/recipetool/create_npm.py b/scripts/lib/recipetool/create_npm.py new file mode 100644 index 0000000000..cb8f338b8b --- /dev/null +++ b/scripts/lib/recipetool/create_npm.py @@ -0,0 +1,344 @@ +# Recipe creation tool - node.js NPM module support plugin +# +# Copyright (C) 2016 Intel Corporation +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +import os +import logging +import subprocess +import tempfile +import shutil +import json +from recipetool.create import RecipeHandler, split_pkg_licenses, handle_license_vars, check_npm + +logger = logging.getLogger('recipetool') + + +tinfoil = None + +def tinfoil_init(instance): + global tinfoil + tinfoil = instance + + +class NpmRecipeHandler(RecipeHandler): + lockdownpath = None + + def _handle_license(self, data): + ''' + Handle the license value from an npm package.json file + ''' + license = None + if 'license' in data: + license = data['license'] + if isinstance(license, dict): + license = license.get('type', None) + if license: + if 'OR' in license: + license = license.replace('OR', '|') + license = license.replace('AND', '&') + license = license.replace(' ', '_') + if not license[0] == '(': + license = '(' + license + ')' + print('LICENSE: {}'.format(license)) + else: + license = license.replace('AND', '&') + if license[0] == '(': + license = license[1:] + if license[-1] == ')': + license = license[:-1] + license = license.replace('MIT/X11', 'MIT') + license = license.replace('Public Domain', 'PD') + license = license.replace('SEE LICENSE IN EULA', + 'SEE-LICENSE-IN-EULA') + return license + + def _shrinkwrap(self, srctree, localfilesdir, extravalues, lines_before, d): + try: + runenv = dict(os.environ, PATH=d.getVar('PATH')) + bb.process.run('npm shrinkwrap', cwd=srctree, stderr=subprocess.STDOUT, env=runenv, shell=True) + except bb.process.ExecutionError as e: + logger.warn('npm shrinkwrap failed:\n%s' % e.stdout) + return + + tmpfile = os.path.join(localfilesdir, 'npm-shrinkwrap.json') + shutil.move(os.path.join(srctree, 'npm-shrinkwrap.json'), tmpfile) + extravalues.setdefault('extrafiles', {}) + extravalues['extrafiles']['npm-shrinkwrap.json'] = tmpfile + lines_before.append('NPM_SHRINKWRAP := "${THISDIR}/${PN}/npm-shrinkwrap.json"') + + def _lockdown(self, srctree, localfilesdir, extravalues, lines_before, d): + runenv = dict(os.environ, PATH=d.getVar('PATH')) + if not NpmRecipeHandler.lockdownpath: + NpmRecipeHandler.lockdownpath = tempfile.mkdtemp('recipetool-npm-lockdown') + bb.process.run('npm install lockdown --prefix %s' % NpmRecipeHandler.lockdownpath, + cwd=srctree, stderr=subprocess.STDOUT, env=runenv, shell=True) + relockbin = os.path.join(NpmRecipeHandler.lockdownpath, 'node_modules', 'lockdown', 'relock.js') + if not os.path.exists(relockbin): + logger.warn('Could not find relock.js within lockdown directory; skipping lockdown') + return + try: + bb.process.run('node %s' % relockbin, cwd=srctree, stderr=subprocess.STDOUT, env=runenv, shell=True) + except bb.process.ExecutionError as e: + logger.warn('lockdown-relock failed:\n%s' % e.stdout) + return + + tmpfile = os.path.join(localfilesdir, 'lockdown.json') + shutil.move(os.path.join(srctree, 'lockdown.json'), tmpfile) + extravalues.setdefault('extrafiles', {}) + extravalues['extrafiles']['lockdown.json'] = tmpfile + lines_before.append('NPM_LOCKDOWN := "${THISDIR}/${PN}/lockdown.json"') + + def _handle_dependencies(self, d, deps, optdeps, devdeps, lines_before, srctree): + import scriptutils + # If this isn't a single module we need to get the dependencies + # and add them to SRC_URI + def varfunc(varname, origvalue, op, newlines): + if varname == 'SRC_URI': + if not origvalue.startswith('npm://'): + src_uri = origvalue.split() + changed = False + deplist = {} + for dep, depver in optdeps.items(): + depdata = self.get_npm_data(dep, depver, d) + if self.check_npm_optional_dependency(depdata): + deplist[dep] = depdata + for dep, depver in devdeps.items(): + depdata = self.get_npm_data(dep, depver, d) + if self.check_npm_optional_dependency(depdata): + deplist[dep] = depdata + for dep, depver in deps.items(): + depdata = self.get_npm_data(dep, depver, d) + deplist[dep] = depdata + + for dep, depdata in deplist.items(): + version = depdata.get('version', None) + if version: + url = 'npm://registry.npmjs.org;name=%s;version=%s;subdir=node_modules/%s' % (dep, version, dep) + scriptutils.fetch_uri(d, url, srctree) + src_uri.append(url) + changed = True + if changed: + return src_uri, None, -1, True + return origvalue, None, 0, True + updated, newlines = bb.utils.edit_metadata(lines_before, ['SRC_URI'], varfunc) + if updated: + del lines_before[:] + for line in newlines: + # Hack to avoid newlines that edit_metadata inserts + if line.endswith('\n'): + line = line[:-1] + lines_before.append(line) + return updated + + def _replace_license_vars(self, srctree, lines_before, handled, extravalues, d): + for item in handled: + if isinstance(item, tuple): + if item[0] == 'license': + del item + break + + calledvars = [] + def varfunc(varname, origvalue, op, newlines): + if varname in ['LICENSE', 'LIC_FILES_CHKSUM']: + for i, e in enumerate(reversed(newlines)): + if not e.startswith('#'): + stop = i + while stop > 0: + newlines.pop() + stop -= 1 + break + calledvars.append(varname) + if len(calledvars) > 1: + # The second time around, put the new license text in + insertpos = len(newlines) + handle_license_vars(srctree, newlines, handled, extravalues, d) + return None, None, 0, True + return origvalue, None, 0, True + updated, newlines = bb.utils.edit_metadata(lines_before, ['LICENSE', 'LIC_FILES_CHKSUM'], varfunc) + if updated: + del lines_before[:] + lines_before.extend(newlines) + else: + raise Exception('Did not find license variables') + + def process(self, srctree, classes, lines_before, lines_after, handled, extravalues): + import bb.utils + import oe + from collections import OrderedDict + + if 'buildsystem' in handled: + return False + + def read_package_json(fn): + with open(fn, 'r', errors='surrogateescape') as f: + return json.loads(f.read()) + + files = RecipeHandler.checkfiles(srctree, ['package.json']) + if files: + d = bb.data.createCopy(tinfoil.config_data) + npm_bindir = check_npm(tinfoil, self._devtool) + d.prependVar('PATH', '%s:' % npm_bindir) + + data = read_package_json(files[0]) + if 'name' in data and 'version' in data: + extravalues['PN'] = data['name'] + extravalues['PV'] = data['version'] + classes.append('npm') + handled.append('buildsystem') + if 'description' in data: + extravalues['SUMMARY'] = data['description'] + if 'homepage' in data: + extravalues['HOMEPAGE'] = data['homepage'] + + fetchdev = extravalues['fetchdev'] or None + deps, optdeps, devdeps = self.get_npm_package_dependencies(data, fetchdev) + updated = self._handle_dependencies(d, deps, optdeps, devdeps, lines_before, srctree) + if updated: + # We need to redo the license stuff + self._replace_license_vars(srctree, lines_before, handled, extravalues, d) + + # Shrinkwrap + localfilesdir = tempfile.mkdtemp(prefix='recipetool-npm') + self._shrinkwrap(srctree, localfilesdir, extravalues, lines_before, d) + + # Lockdown + self._lockdown(srctree, localfilesdir, extravalues, lines_before, d) + + # Split each npm module out to is own package + npmpackages = oe.package.npm_split_package_dirs(srctree) + for item in handled: + if isinstance(item, tuple): + if item[0] == 'license': + licvalues = item[1] + break + if licvalues: + # Augment the license list with information we have in the packages + licenses = {} + license = self._handle_license(data) + if license: + licenses['${PN}'] = license + for pkgname, pkgitem in npmpackages.items(): + _, pdata = pkgitem + license = self._handle_license(pdata) + if license: + licenses[pkgname] = license + # Now write out the package-specific license values + # We need to strip out the json data dicts for this since split_pkg_licenses + # isn't expecting it + packages = OrderedDict((x,y[0]) for x,y in npmpackages.items()) + packages['${PN}'] = '' + pkglicenses = split_pkg_licenses(licvalues, packages, lines_after, licenses) + all_licenses = list(set([item.replace('_', ' ') for pkglicense in pkglicenses.values() for item in pkglicense])) + if '&' in all_licenses: + all_licenses.remove('&') + # Go back and update the LICENSE value since we have a bit more + # information than when that was written out (and we know all apply + # vs. there being a choice, so we can join them with &) + for i, line in enumerate(lines_before): + if line.startswith('LICENSE = '): + lines_before[i] = 'LICENSE = "%s"' % ' & '.join(all_licenses) + break + + # Need to move S setting after inherit npm + for i, line in enumerate(lines_before): + if line.startswith('S ='): + lines_before.pop(i) + lines_after.insert(0, '# Must be set after inherit npm since that itself sets S') + lines_after.insert(1, line) + break + + return True + + return False + + # FIXME this is duplicated from lib/bb/fetch2/npm.py + def _parse_view(self, output): + ''' + Parse the output of npm view --json; the last JSON result + is assumed to be the one that we're interested in. + ''' + pdata = None + outdeps = {} + datalines = [] + bracelevel = 0 + for line in output.splitlines(): + if bracelevel: + datalines.append(line) + elif '{' in line: + datalines = [] + datalines.append(line) + bracelevel = bracelevel + line.count('{') - line.count('}') + if datalines: + pdata = json.loads('\n'.join(datalines)) + return pdata + + # FIXME this is effectively duplicated from lib/bb/fetch2/npm.py + # (split out from _getdependencies()) + def get_npm_data(self, pkg, version, d): + import bb.fetch2 + pkgfullname = pkg + if version != '*' and not '/' in version: + pkgfullname += "@'%s'" % version + logger.debug(2, "Calling getdeps on %s" % pkg) + runenv = dict(os.environ, PATH=d.getVar('PATH')) + fetchcmd = "npm view %s --json" % pkgfullname + output, _ = bb.process.run(fetchcmd, stderr=subprocess.STDOUT, env=runenv, shell=True) + data = self._parse_view(output) + return data + + # FIXME this is effectively duplicated from lib/bb/fetch2/npm.py + # (split out from _getdependencies()) + def get_npm_package_dependencies(self, pdata, fetchdev): + dependencies = pdata.get('dependencies', {}) + optionalDependencies = pdata.get('optionalDependencies', {}) + dependencies.update(optionalDependencies) + if fetchdev: + devDependencies = pdata.get('devDependencies', {}) + dependencies.update(devDependencies) + else: + devDependencies = {} + depsfound = {} + optdepsfound = {} + devdepsfound = {} + for dep in dependencies: + if dep in optionalDependencies: + optdepsfound[dep] = dependencies[dep] + elif dep in devDependencies: + devdepsfound[dep] = dependencies[dep] + else: + depsfound[dep] = dependencies[dep] + return depsfound, optdepsfound, devdepsfound + + # FIXME this is effectively duplicated from lib/bb/fetch2/npm.py + # (split out from _getdependencies()) + def check_npm_optional_dependency(self, pdata): + pkg_os = pdata.get('os', None) + if pkg_os: + if not isinstance(pkg_os, list): + pkg_os = [pkg_os] + blacklist = False + for item in pkg_os: + if item.startswith('!'): + blacklist = True + break + if (not blacklist and 'linux' not in pkg_os) or '!linux' in pkg_os: + logger.debug(2, "Skipping %s since it's incompatible with Linux" % pkg) + return False + return True + + +def register_recipe_handlers(handlers): + handlers.append((NpmRecipeHandler(), 60)) diff --git a/scripts/lib/recipetool/newappend.py b/scripts/lib/recipetool/newappend.py new file mode 100644 index 0000000000..0b63759d8c --- /dev/null +++ b/scripts/lib/recipetool/newappend.py @@ -0,0 +1,89 @@ +# Recipe creation tool - newappend plugin +# +# This sub-command creates a bbappend for the specified target and prints the +# path to the bbappend. +# +# Example: recipetool newappend meta-mylayer busybox +# +# Copyright (C) 2015 Christopher Larson <kergoth@gmail.com> +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +import argparse +import errno +import logging +import os +import re +import subprocess +import sys +import scriptutils + + +logger = logging.getLogger('recipetool') +tinfoil = None + + +def tinfoil_init(instance): + global tinfoil + tinfoil = instance + + +def layer(layerpath): + if not os.path.exists(os.path.join(layerpath, 'conf', 'layer.conf')): + raise argparse.ArgumentTypeError('{0!r} must be a path to a valid layer'.format(layerpath)) + return layerpath + + +def newappend(args): + import oe.recipeutils + + recipe_path = tinfoil.get_recipe_file(args.target) + + rd = tinfoil.config_data.createCopy() + rd.setVar('FILE', recipe_path) + append_path, path_ok = oe.recipeutils.get_bbappend_path(rd, args.destlayer, args.wildcard_version) + if not append_path: + logger.error('Unable to determine layer directory containing %s', recipe_path) + return 1 + + if not path_ok: + logger.warn('Unable to determine correct subdirectory path for bbappend file - check that what %s adds to BBFILES also matches .bbappend files. Using %s for now, but until you fix this the bbappend will not be applied.', os.path.join(args.destlayer, 'conf', 'layer.conf'), os.path.dirname(append_path)) + + layerdirs = [os.path.abspath(layerdir) for layerdir in rd.getVar('BBLAYERS').split()] + if not os.path.abspath(args.destlayer) in layerdirs: + logger.warn('Specified layer is not currently enabled in bblayers.conf, you will need to add it before this bbappend will be active') + + if not os.path.exists(append_path): + bb.utils.mkdirhier(os.path.dirname(append_path)) + + try: + open(append_path, 'a').close() + except (OSError, IOError) as exc: + logger.critical(str(exc)) + return 1 + + if args.edit: + return scriptutils.run_editor([append_path, recipe_path]) + else: + print(append_path) + + +def register_commands(subparsers): + parser = subparsers.add_parser('newappend', + help='Create a bbappend for the specified target in the specified layer') + parser.add_argument('-e', '--edit', help='Edit the new append. This obeys $VISUAL if set, otherwise $EDITOR, otherwise vi.', action='store_true') + parser.add_argument('-w', '--wildcard-version', help='Use wildcard to make the bbappend apply to any recipe version', action='store_true') + parser.add_argument('destlayer', help='Base directory of the destination layer to write the bbappend to', type=layer) + parser.add_argument('target', help='Target recipe/provide to append') + parser.set_defaults(func=newappend, parserecipes=True) diff --git a/scripts/lib/recipetool/setvar.py b/scripts/lib/recipetool/setvar.py new file mode 100644 index 0000000000..9de315a0ef --- /dev/null +++ b/scripts/lib/recipetool/setvar.py @@ -0,0 +1,75 @@ +# Recipe creation tool - set variable plugin +# +# Copyright (C) 2015 Intel Corporation +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +import sys +import os +import argparse +import glob +import fnmatch +import re +import logging +import scriptutils + +logger = logging.getLogger('recipetool') + +tinfoil = None +plugins = None + +def tinfoil_init(instance): + global tinfoil + tinfoil = instance + +def setvar(args): + import oe.recipeutils + + if args.delete: + if args.value: + logger.error('-D/--delete and specifying a value are mutually exclusive') + return 1 + value = None + else: + if args.value is None: + logger.error('You must specify a value if not using -D/--delete') + return 1 + value = args.value + varvalues = {args.varname: value} + + if args.recipe_only: + patches = [oe.recipeutils.patch_recipe_file(args.recipefile, varvalues, patch=args.patch)] + else: + rd = tinfoil.parse_recipe_file(args.recipefile, False) + if not rd: + return 1 + patches = oe.recipeutils.patch_recipe(rd, args.recipefile, varvalues, patch=args.patch) + if args.patch: + for patch in patches: + for line in patch: + sys.stdout.write(line) + return 0 + + +def register_commands(subparsers): + parser_setvar = subparsers.add_parser('setvar', + help='Set a variable within a recipe', + description='Adds/updates the value a variable is set to in a recipe') + parser_setvar.add_argument('recipefile', help='Recipe file to update') + parser_setvar.add_argument('varname', help='Variable name to set') + parser_setvar.add_argument('value', nargs='?', help='New value to set the variable to') + parser_setvar.add_argument('--recipe-only', '-r', help='Do not set variable in any include file if present', action='store_true') + parser_setvar.add_argument('--patch', '-p', help='Create a patch to make the change instead of modifying the recipe', action='store_true') + parser_setvar.add_argument('--delete', '-D', help='Delete the specified value instead of setting it', action='store_true') + parser_setvar.set_defaults(func=setvar) diff --git a/scripts/lib/scriptutils.py b/scripts/lib/scriptutils.py new file mode 100644 index 0000000000..4ccbe5c108 --- /dev/null +++ b/scripts/lib/scriptutils.py @@ -0,0 +1,135 @@ +# Script utility functions +# +# Copyright (C) 2014 Intel Corporation +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +import sys +import os +import logging +import glob +import argparse +import subprocess + +def logger_create(name, stream=None): + logger = logging.getLogger(name) + loggerhandler = logging.StreamHandler(stream=stream) + loggerhandler.setFormatter(logging.Formatter("%(levelname)s: %(message)s")) + logger.addHandler(loggerhandler) + logger.setLevel(logging.INFO) + return logger + +def logger_setup_color(logger, color='auto'): + from bb.msg import BBLogFormatter + console = logging.StreamHandler(sys.stdout) + formatter = BBLogFormatter("%(levelname)s: %(message)s") + console.setFormatter(formatter) + logger.handlers = [console] + if color == 'always' or (color=='auto' and console.stream.isatty()): + formatter.enable_color() + + +def load_plugins(logger, plugins, pluginpath): + import imp + + def load_plugin(name): + logger.debug('Loading plugin %s' % name) + fp, pathname, description = imp.find_module(name, [pluginpath]) + try: + return imp.load_module(name, fp, pathname, description) + finally: + if fp: + fp.close() + + def plugin_name(filename): + return os.path.splitext(os.path.basename(filename))[0] + + known_plugins = [plugin_name(p.__name__) for p in plugins] + logger.debug('Loading plugins from %s...' % pluginpath) + for fn in glob.glob(os.path.join(pluginpath, '*.py')): + name = plugin_name(fn) + if name != '__init__' and name not in known_plugins: + plugin = load_plugin(name) + if hasattr(plugin, 'plugin_init'): + plugin.plugin_init(plugins) + plugins.append(plugin) + +def git_convert_standalone_clone(repodir): + """If specified directory is a git repository, ensure it's a standalone clone""" + import bb.process + if os.path.exists(os.path.join(repodir, '.git')): + alternatesfile = os.path.join(repodir, '.git', 'objects', 'info', 'alternates') + if os.path.exists(alternatesfile): + # This will have been cloned with -s, so we need to convert it so none + # of the contents is shared + bb.process.run('git repack -a', cwd=repodir) + os.remove(alternatesfile) + +def fetch_uri(d, uri, destdir, srcrev=None): + """Fetch a URI to a local directory""" + import bb.data + bb.utils.mkdirhier(destdir) + localdata = bb.data.createCopy(d) + localdata.setVar('BB_STRICT_CHECKSUM', '') + localdata.setVar('SRCREV', srcrev) + ret = (None, None) + olddir = os.getcwd() + try: + fetcher = bb.fetch2.Fetch([uri], localdata) + for u in fetcher.ud: + ud = fetcher.ud[u] + ud.ignore_checksums = True + fetcher.download() + for u in fetcher.ud: + ud = fetcher.ud[u] + if ud.localpath.rstrip(os.sep) == localdata.getVar('DL_DIR').rstrip(os.sep): + raise Exception('Local path is download directory - please check that the URI "%s" is correct' % uri) + fetcher.unpack(destdir) + for u in fetcher.ud: + ud = fetcher.ud[u] + if ud.method.recommends_checksum(ud): + md5value = bb.utils.md5_file(ud.localpath) + sha256value = bb.utils.sha256_file(ud.localpath) + ret = (md5value, sha256value) + finally: + os.chdir(olddir) + return ret + +def run_editor(fn): + if isinstance(fn, str): + params = '"%s"' % fn + else: + params = '' + for fnitem in fn: + params += ' "%s"' % fnitem + + editor = os.getenv('VISUAL', os.getenv('EDITOR', 'vi')) + try: + return subprocess.check_call('%s %s' % (editor, params), shell=True) + except OSError as exc: + logger.error("Execution of editor '%s' failed: %s", editor, exc) + return 1 + +def is_src_url(param): + """ + Check if a parameter is a URL and return True if so + NOTE: be careful about changing this as it will influence how devtool/recipetool command line handling works + """ + if not param: + return False + elif '://' in param: + return True + elif param.startswith('git@') or ('@' in param and param.endswith('.git')): + return True + return False diff --git a/scripts/lib/wic/__init__.py b/scripts/lib/wic/__init__.py new file mode 100644 index 0000000000..85876b138c --- /dev/null +++ b/scripts/lib/wic/__init__.py @@ -0,0 +1,20 @@ +#!/usr/bin/env python -tt +# +# Copyright (c) 2007 Red Hat, Inc. +# Copyright (c) 2011 Intel, Inc. +# +# This program is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by the Free +# Software Foundation; version 2 of the License +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY +# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., 59 +# Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +class WicError(Exception): + pass diff --git a/scripts/lib/wic/canned-wks/common.wks.inc b/scripts/lib/wic/canned-wks/common.wks.inc new file mode 100644 index 0000000000..5cf2fd1f3e --- /dev/null +++ b/scripts/lib/wic/canned-wks/common.wks.inc @@ -0,0 +1,3 @@ +# This file is included into 3 canned wks files from this directory +part /boot --source bootimg-pcbios --ondisk sda --label boot --active --align 1024 +part / --source rootfs --ondisk sda --fstype=ext4 --label platform --align 1024 diff --git a/scripts/lib/wic/canned-wks/directdisk-bootloader-config.cfg b/scripts/lib/wic/canned-wks/directdisk-bootloader-config.cfg new file mode 100644 index 0000000000..d5a07d2048 --- /dev/null +++ b/scripts/lib/wic/canned-wks/directdisk-bootloader-config.cfg @@ -0,0 +1,27 @@ +# This is an example configuration file for syslinux. +TIMEOUT 50 +ALLOWOPTIONS 1 +SERIAL 0 115200 +PROMPT 0 + +UI vesamenu.c32 +menu title Select boot options +menu tabmsg Press [Tab] to edit, [Return] to select + +DEFAULT Graphics console boot + +LABEL Graphics console boot +KERNEL /vmlinuz +APPEND label=boot root=/dev/sda2 rootwait + +LABEL Serial console boot +KERNEL /vmlinuz +APPEND label=boot root=/dev/sda2 rootwait console=ttyS0,115200 + +LABEL Graphics console install +KERNEL /vmlinuz +APPEND label=install root=/dev/sda2 rootwait + +LABEL Serial console install +KERNEL /vmlinuz +APPEND label=install root=/dev/sda2 rootwait console=ttyS0,115200 diff --git a/scripts/lib/wic/canned-wks/directdisk-bootloader-config.wks b/scripts/lib/wic/canned-wks/directdisk-bootloader-config.wks new file mode 100644 index 0000000000..3529e05c87 --- /dev/null +++ b/scripts/lib/wic/canned-wks/directdisk-bootloader-config.wks @@ -0,0 +1,8 @@ +# short-description: Create a 'pcbios' direct disk image with custom bootloader config +# long-description: Creates a partitioned legacy BIOS disk image that the user +# can directly dd to boot media. The bootloader configuration source is a user file. + +include common.wks.inc + +bootloader --configfile="directdisk-bootloader-config.cfg" + diff --git a/scripts/lib/image/canned-wks/directdisk.wks b/scripts/lib/wic/canned-wks/directdisk-gpt.wks index 62dcab15ce..8d7d8de6ea 100644 --- a/scripts/lib/image/canned-wks/directdisk.wks +++ b/scripts/lib/wic/canned-wks/directdisk-gpt.wks @@ -4,7 +4,7 @@ part /boot --source bootimg-pcbios --ondisk sda --label boot --active --align 1024 -part / --source rootfs --ondisk sda --fstype=ext3 --label platform --align 1024 +part / --source rootfs --ondisk sda --fstype=ext4 --label platform --align 1024 --use-uuid -bootloader --timeout=0 --append="rootwait rootfstype=ext3 video=vesafb vga=0x318 console=tty0" +bootloader --ptable gpt --timeout=0 --append="rootwait rootfstype=ext4 video=vesafb vga=0x318 console=tty0 console=ttyS0,115200n8" diff --git a/scripts/lib/wic/canned-wks/directdisk-multi-rootfs.wks b/scripts/lib/wic/canned-wks/directdisk-multi-rootfs.wks new file mode 100644 index 0000000000..f61d941d6d --- /dev/null +++ b/scripts/lib/wic/canned-wks/directdisk-multi-rootfs.wks @@ -0,0 +1,23 @@ +# short-description: Create multi rootfs image using rootfs plugin +# long-description: Creates a partitioned disk image with two rootfs partitions +# using rootfs plugin. +# +# Partitions can use either +# - indirect rootfs references to image recipe(s): +# wic create directdisk-multi-indirect-recipes -e core-image-minimal \ +# --rootfs-dir rootfs1=core-image-minimal +# --rootfs-dir rootfs2=core-image-minimal-dev +# +# - or paths to rootfs directories: +# wic create directdisk-multi-rootfs \ +# --rootfs-dir rootfs1=tmp/work/qemux86_64-poky-linux/core-image-minimal/1.0-r0/rootfs/ +# --rootfs-dir rootfs2=tmp/work/qemux86_64-poky-linux/core-image-minimal-dev/1.0-r0/rootfs/ +# +# - or any combinations of -r and --rootfs command line options + +part /boot --source bootimg-pcbios --ondisk sda --label boot --active --align 1024 +part / --source rootfs --rootfs-dir=rootfs1 --ondisk sda --fstype=ext4 --label platform --align 1024 +part /rescue --source rootfs --rootfs-dir=rootfs2 --ondisk sda --fstype=ext4 --label secondary --align 1024 + +bootloader --timeout=0 --append="rootwait rootfstype=ext4 video=vesafb vga=0x318 console=tty0 console=ttyS0,115200n8" + diff --git a/scripts/lib/wic/canned-wks/directdisk.wks b/scripts/lib/wic/canned-wks/directdisk.wks new file mode 100644 index 0000000000..8c8e06b02c --- /dev/null +++ b/scripts/lib/wic/canned-wks/directdisk.wks @@ -0,0 +1,8 @@ +# short-description: Create a 'pcbios' direct disk image +# long-description: Creates a partitioned legacy BIOS disk image that the user +# can directly dd to boot media. + +include common.wks.inc + +bootloader --timeout=0 --append="rootwait rootfstype=ext4 video=vesafb vga=0x318 console=tty0 console=ttyS0,115200n8" + diff --git a/scripts/lib/wic/canned-wks/mkefidisk.wks b/scripts/lib/wic/canned-wks/mkefidisk.wks new file mode 100644 index 0000000000..9f534fe184 --- /dev/null +++ b/scripts/lib/wic/canned-wks/mkefidisk.wks @@ -0,0 +1,11 @@ +# short-description: Create an EFI disk image +# long-description: Creates a partitioned EFI disk image that the user +# can directly dd to boot media. + +part /boot --source bootimg-efi --sourceparams="loader=grub-efi" --ondisk sda --label msdos --active --align 1024 + +part / --source rootfs --ondisk sda --fstype=ext4 --label platform --align 1024 --use-uuid + +part swap --ondisk sda --size 44 --label swap1 --fstype=swap + +bootloader --ptable gpt --timeout=5 --append="rootfstype=ext4 console=ttyS0,115200 console=tty0" diff --git a/scripts/lib/wic/canned-wks/mkhybridiso.wks b/scripts/lib/wic/canned-wks/mkhybridiso.wks new file mode 100644 index 0000000000..9d34e9b477 --- /dev/null +++ b/scripts/lib/wic/canned-wks/mkhybridiso.wks @@ -0,0 +1,7 @@ +# short-description: Create a hybrid ISO image +# long-description: Creates an EFI and legacy bootable hybrid ISO image +# which can be used on optical media as well as USB media. + +part /boot --source isoimage-isohybrid --sourceparams="loader=grub-efi,image_name=HYBRID_ISO_IMG" --ondisk cd --label HYBRIDISO --fstype=ext4 + +bootloader --timeout=15 --append="" diff --git a/scripts/lib/wic/canned-wks/qemux86-directdisk.wks b/scripts/lib/wic/canned-wks/qemux86-directdisk.wks new file mode 100644 index 0000000000..db30bbced0 --- /dev/null +++ b/scripts/lib/wic/canned-wks/qemux86-directdisk.wks @@ -0,0 +1,8 @@ +# short-description: Create a qemu machine 'pcbios' direct disk image +# long-description: Creates a partitioned legacy BIOS disk image that the user +# can directly use to boot a qemu machine. + +include common.wks.inc + +bootloader --timeout=0 --append="vga=0 uvesafb.mode_option=640x480-32 root=/dev/sda2 rw mem=256M ip=192.168.7.2::192.168.7.1:255.255.255.0 oprofile.timer=1 rootfstype=ext4 " + diff --git a/scripts/lib/wic/canned-wks/sdimage-bootpart.wks b/scripts/lib/wic/canned-wks/sdimage-bootpart.wks new file mode 100644 index 0000000000..7ffd632f4a --- /dev/null +++ b/scripts/lib/wic/canned-wks/sdimage-bootpart.wks @@ -0,0 +1,6 @@ +# short-description: Create SD card image with a boot partition +# long-description: Creates a partitioned SD card image. Boot files +# are located in the first vfat partition. + +part /boot --source bootimg-partition --ondisk mmcblk --fstype=vfat --label boot --active --align 4 --size 16 +part / --source rootfs --ondisk mmcblk --fstype=ext4 --label root --align 4 diff --git a/scripts/lib/wic/canned-wks/systemd-bootdisk.wks b/scripts/lib/wic/canned-wks/systemd-bootdisk.wks new file mode 100644 index 0000000000..4bd9d6a65f --- /dev/null +++ b/scripts/lib/wic/canned-wks/systemd-bootdisk.wks @@ -0,0 +1,11 @@ +# short-description: Create an EFI disk image with systemd-boot +# long-description: Creates a partitioned EFI disk image that the user +# can directly dd to boot media. The selected bootloader is systemd-boot. + +part /boot --source bootimg-efi --sourceparams="loader=systemd-boot" --ondisk sda --label msdos --active --align 1024 + +part / --source rootfs --ondisk sda --fstype=ext4 --label platform --align 1024 --use-uuid + +part swap --ondisk sda --size 44 --label swap1 --fstype=swap + +bootloader --ptable gpt --timeout=5 --append="rootwait rootfstype=ext4 console=ttyS0,115200 console=tty0" diff --git a/scripts/lib/wic/engine.py b/scripts/lib/wic/engine.py new file mode 100644 index 0000000000..f59821fea6 --- /dev/null +++ b/scripts/lib/wic/engine.py @@ -0,0 +1,257 @@ +# ex:ts=4:sw=4:sts=4:et +# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- +# +# Copyright (c) 2013, Intel Corporation. +# All rights reserved. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +# +# DESCRIPTION + +# This module implements the image creation engine used by 'wic' to +# create images. The engine parses through the OpenEmbedded kickstart +# (wks) file specified and generates images that can then be directly +# written onto media. +# +# AUTHORS +# Tom Zanussi <tom.zanussi (at] linux.intel.com> +# + +import logging +import os + +from wic import WicError +from wic.pluginbase import PluginMgr +from wic.utils.misc import get_bitbake_var + +logger = logging.getLogger('wic') + +def verify_build_env(): + """ + Verify that the build environment is sane. + + Returns True if it is, false otherwise + """ + if not os.environ.get("BUILDDIR"): + raise WicError("BUILDDIR not found, exiting. (Did you forget to source oe-init-build-env?)") + + return True + + +CANNED_IMAGE_DIR = "lib/wic/canned-wks" # relative to scripts +SCRIPTS_CANNED_IMAGE_DIR = "scripts/" + CANNED_IMAGE_DIR +WIC_DIR = "wic" + +def build_canned_image_list(path): + layers_path = get_bitbake_var("BBLAYERS") + canned_wks_layer_dirs = [] + + if layers_path is not None: + for layer_path in layers_path.split(): + for wks_path in (WIC_DIR, SCRIPTS_CANNED_IMAGE_DIR): + cpath = os.path.join(layer_path, wks_path) + if os.path.isdir(cpath): + canned_wks_layer_dirs.append(cpath) + + cpath = os.path.join(path, CANNED_IMAGE_DIR) + canned_wks_layer_dirs.append(cpath) + + return canned_wks_layer_dirs + +def find_canned_image(scripts_path, wks_file): + """ + Find a .wks file with the given name in the canned files dir. + + Return False if not found + """ + layers_canned_wks_dir = build_canned_image_list(scripts_path) + + for canned_wks_dir in layers_canned_wks_dir: + for root, dirs, files in os.walk(canned_wks_dir): + for fname in files: + if fname.endswith("~") or fname.endswith("#"): + continue + if fname.endswith(".wks") and wks_file + ".wks" == fname: + fullpath = os.path.join(canned_wks_dir, fname) + return fullpath + return None + + +def list_canned_images(scripts_path): + """ + List the .wks files in the canned image dir, minus the extension. + """ + layers_canned_wks_dir = build_canned_image_list(scripts_path) + + for canned_wks_dir in layers_canned_wks_dir: + for root, dirs, files in os.walk(canned_wks_dir): + for fname in files: + if fname.endswith("~") or fname.endswith("#"): + continue + if fname.endswith(".wks"): + fullpath = os.path.join(canned_wks_dir, fname) + with open(fullpath) as wks: + for line in wks: + desc = "" + idx = line.find("short-description:") + if idx != -1: + desc = line[idx + len("short-description:"):].strip() + break + basename = os.path.splitext(fname)[0] + print(" %s\t\t%s" % (basename.ljust(30), desc)) + + +def list_canned_image_help(scripts_path, fullpath): + """ + List the help and params in the specified canned image. + """ + found = False + with open(fullpath) as wks: + for line in wks: + if not found: + idx = line.find("long-description:") + if idx != -1: + print() + print(line[idx + len("long-description:"):].strip()) + found = True + continue + if not line.strip(): + break + idx = line.find("#") + if idx != -1: + print(line[idx + len("#:"):].rstrip()) + else: + break + + +def list_source_plugins(): + """ + List the available source plugins i.e. plugins available for --source. + """ + plugins = PluginMgr.get_plugins('source') + + for plugin in plugins: + print(" %s" % plugin) + + +def wic_create(wks_file, rootfs_dir, bootimg_dir, kernel_dir, + native_sysroot, options): + """ + Create image + + wks_file - user-defined OE kickstart file + rootfs_dir - absolute path to the build's /rootfs dir + bootimg_dir - absolute path to the build's boot artifacts directory + kernel_dir - absolute path to the build's kernel directory + native_sysroot - absolute path to the build's native sysroots dir + image_output_dir - dirname to create for image + options - wic command line options (debug, bmap, etc) + + Normally, the values for the build artifacts values are determined + by 'wic -e' from the output of the 'bitbake -e' command given an + image name e.g. 'core-image-minimal' and a given machine set in + local.conf. If that's the case, the variables get the following + values from the output of 'bitbake -e': + + rootfs_dir: IMAGE_ROOTFS + kernel_dir: DEPLOY_DIR_IMAGE + native_sysroot: STAGING_DIR_NATIVE + + In the above case, bootimg_dir remains unset and the + plugin-specific image creation code is responsible for finding the + bootimg artifacts. + + In the case where the values are passed in explicitly i.e 'wic -e' + is not used but rather the individual 'wic' options are used to + explicitly specify these values. + """ + try: + oe_builddir = os.environ["BUILDDIR"] + except KeyError: + raise WicError("BUILDDIR not found, exiting. (Did you forget to source oe-init-build-env?)") + + if not os.path.exists(options.outdir): + os.makedirs(options.outdir) + + pname = 'direct' + plugin_class = PluginMgr.get_plugins('imager').get(pname) + if not plugin_class: + raise WicError('Unknown plugin: %s' % pname) + + plugin = plugin_class(wks_file, rootfs_dir, bootimg_dir, kernel_dir, + native_sysroot, oe_builddir, options) + + plugin.do_create() + + logger.info("The image(s) were created using OE kickstart file:\n %s", wks_file) + + +def wic_list(args, scripts_path): + """ + Print the list of images or source plugins. + """ + if len(args) < 1: + return False + + if args == ["images"]: + list_canned_images(scripts_path) + return True + elif args == ["source-plugins"]: + list_source_plugins() + return True + elif len(args) == 2 and args[1] == "help": + wks_file = args[0] + fullpath = find_canned_image(scripts_path, wks_file) + if not fullpath: + raise WicError("No image named %s found, exiting. " + "(Use 'wic list images' to list available images, " + "or specify a fully-qualified OE kickstart (.wks) " + "filename)" % wks_file) + + list_canned_image_help(scripts_path, fullpath) + return True + + return False + +def find_canned(scripts_path, file_name): + """ + Find a file either by its path or by name in the canned files dir. + + Return None if not found + """ + if os.path.exists(file_name): + return file_name + + layers_canned_wks_dir = build_canned_image_list(scripts_path) + for canned_wks_dir in layers_canned_wks_dir: + for root, dirs, files in os.walk(canned_wks_dir): + for fname in files: + if fname == file_name: + fullpath = os.path.join(canned_wks_dir, fname) + return fullpath + +def get_custom_config(boot_file): + """ + Get the custom configuration to be used for the bootloader. + + Return None if the file can't be found. + """ + # Get the scripts path of poky + scripts_path = os.path.abspath("%s/../.." % os.path.dirname(__file__)) + + cfg_file = find_canned(scripts_path, boot_file) + if cfg_file: + with open(cfg_file, "r") as f: + config = f.read() + return config diff --git a/scripts/lib/wic/filemap.py b/scripts/lib/wic/filemap.py new file mode 100644 index 0000000000..1f1aacc522 --- /dev/null +++ b/scripts/lib/wic/filemap.py @@ -0,0 +1,564 @@ +# Copyright (c) 2012 Intel, Inc. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License, version 2, +# as published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. + +""" +This module implements python implements a way to get file block. Two methods +are supported - the FIEMAP ioctl and the 'SEEK_HOLE / SEEK_DATA' features of +the file seek syscall. The former is implemented by the 'FilemapFiemap' class, +the latter is implemented by the 'FilemapSeek' class. Both classes provide the +same API. The 'filemap' function automatically selects which class can be used +and returns an instance of the class. +""" + +# Disable the following pylint recommendations: +# * Too many instance attributes (R0902) +# pylint: disable=R0902 + +import os +import struct +import array +import fcntl +import tempfile +import logging + +def get_block_size(file_obj): + """ + Returns block size for file object 'file_obj'. Errors are indicated by the + 'IOError' exception. + """ + + from fcntl import ioctl + import struct + + # Get the block size of the host file-system for the image file by calling + # the FIGETBSZ ioctl (number 2). + binary_data = ioctl(file_obj, 2, struct.pack('I', 0)) + return struct.unpack('I', binary_data)[0] + +class ErrorNotSupp(Exception): + """ + An exception of this type is raised when the 'FIEMAP' or 'SEEK_HOLE' feature + is not supported either by the kernel or the file-system. + """ + pass + +class Error(Exception): + """A class for all the other exceptions raised by this module.""" + pass + + +class _FilemapBase(object): + """ + This is a base class for a couple of other classes in this module. This + class simply performs the common parts of the initialization process: opens + the image file, gets its size, etc. The 'log' parameter is the logger object + to use for printing messages. + """ + + def __init__(self, image, log=None): + """ + Initialize a class instance. The 'image' argument is full path to the + file or file object to operate on. + """ + + self._log = log + if self._log is None: + self._log = logging.getLogger(__name__) + + self._f_image_needs_close = False + + if hasattr(image, "fileno"): + self._f_image = image + self._image_path = image.name + else: + self._image_path = image + self._open_image_file() + + try: + self.image_size = os.fstat(self._f_image.fileno()).st_size + except IOError as err: + raise Error("cannot get information about file '%s': %s" + % (self._f_image.name, err)) + + try: + self.block_size = get_block_size(self._f_image) + except IOError as err: + raise Error("cannot get block size for '%s': %s" + % (self._image_path, err)) + + self.blocks_cnt = self.image_size + self.block_size - 1 + self.blocks_cnt //= self.block_size + + try: + self._f_image.flush() + except IOError as err: + raise Error("cannot flush image file '%s': %s" + % (self._image_path, err)) + + try: + os.fsync(self._f_image.fileno()), + except OSError as err: + raise Error("cannot synchronize image file '%s': %s " + % (self._image_path, err.strerror)) + + self._log.debug("opened image \"%s\"" % self._image_path) + self._log.debug("block size %d, blocks count %d, image size %d" + % (self.block_size, self.blocks_cnt, self.image_size)) + + def __del__(self): + """The class destructor which just closes the image file.""" + if self._f_image_needs_close: + self._f_image.close() + + def _open_image_file(self): + """Open the image file.""" + try: + self._f_image = open(self._image_path, 'rb') + except IOError as err: + raise Error("cannot open image file '%s': %s" + % (self._image_path, err)) + + self._f_image_needs_close = True + + def block_is_mapped(self, block): # pylint: disable=W0613,R0201 + """ + This method has has to be implemented by child classes. It returns + 'True' if block number 'block' of the image file is mapped and 'False' + otherwise. + """ + + raise Error("the method is not implemented") + + def block_is_unmapped(self, block): # pylint: disable=W0613,R0201 + """ + This method has has to be implemented by child classes. It returns + 'True' if block number 'block' of the image file is not mapped (hole) + and 'False' otherwise. + """ + + raise Error("the method is not implemented") + + def get_mapped_ranges(self, start, count): # pylint: disable=W0613,R0201 + """ + This method has has to be implemented by child classes. This is a + generator which yields ranges of mapped blocks in the file. The ranges + are tuples of 2 elements: [first, last], where 'first' is the first + mapped block and 'last' is the last mapped block. + + The ranges are yielded for the area of the file of size 'count' blocks, + starting from block 'start'. + """ + + raise Error("the method is not implemented") + + def get_unmapped_ranges(self, start, count): # pylint: disable=W0613,R0201 + """ + This method has has to be implemented by child classes. Just like + 'get_mapped_ranges()', but yields unmapped block ranges instead + (holes). + """ + + raise Error("the method is not implemented") + + +# The 'SEEK_HOLE' and 'SEEK_DATA' options of the file seek system call +_SEEK_DATA = 3 +_SEEK_HOLE = 4 + +def _lseek(file_obj, offset, whence): + """This is a helper function which invokes 'os.lseek' for file object + 'file_obj' and with specified 'offset' and 'whence'. The 'whence' + argument is supposed to be either '_SEEK_DATA' or '_SEEK_HOLE'. When + there is no more data or hole starting from 'offset', this function + returns '-1'. Otherwise the data or hole position is returned.""" + + try: + return os.lseek(file_obj.fileno(), offset, whence) + except OSError as err: + # The 'lseek' system call returns the ENXIO if there is no data or + # hole starting from the specified offset. + if err.errno == os.errno.ENXIO: + return -1 + elif err.errno == os.errno.EINVAL: + raise ErrorNotSupp("the kernel or file-system does not support " + "\"SEEK_HOLE\" and \"SEEK_DATA\"") + else: + raise + +class FilemapSeek(_FilemapBase): + """ + This class uses the 'SEEK_HOLE' and 'SEEK_DATA' to find file block mapping. + Unfortunately, the current implementation requires the caller to have write + access to the image file. + """ + + def __init__(self, image, log=None): + """Refer the '_FilemapBase' class for the documentation.""" + + # Call the base class constructor first + _FilemapBase.__init__(self, image, log) + self._log.debug("FilemapSeek: initializing") + + self._probe_seek_hole() + + def _probe_seek_hole(self): + """ + Check whether the system implements 'SEEK_HOLE' and 'SEEK_DATA'. + Unfortunately, there seems to be no clean way for detecting this, + because often the system just fakes them by just assuming that all + files are fully mapped, so 'SEEK_HOLE' always returns EOF and + 'SEEK_DATA' always returns the requested offset. + + I could not invent a better way of detecting the fake 'SEEK_HOLE' + implementation than just to create a temporary file in the same + directory where the image file resides. It would be nice to change this + to something better. + """ + + directory = os.path.dirname(self._image_path) + + try: + tmp_obj = tempfile.TemporaryFile("w+", dir=directory) + except IOError as err: + raise ErrorNotSupp("cannot create a temporary in \"%s\": %s" + % (directory, err)) + + try: + os.ftruncate(tmp_obj.fileno(), self.block_size) + except OSError as err: + raise ErrorNotSupp("cannot truncate temporary file in \"%s\": %s" + % (directory, err)) + + offs = _lseek(tmp_obj, 0, _SEEK_HOLE) + if offs != 0: + # We are dealing with the stub 'SEEK_HOLE' implementation which + # always returns EOF. + self._log.debug("lseek(0, SEEK_HOLE) returned %d" % offs) + raise ErrorNotSupp("the file-system does not support " + "\"SEEK_HOLE\" and \"SEEK_DATA\" but only " + "provides a stub implementation") + + tmp_obj.close() + + def block_is_mapped(self, block): + """Refer the '_FilemapBase' class for the documentation.""" + offs = _lseek(self._f_image, block * self.block_size, _SEEK_DATA) + if offs == -1: + result = False + else: + result = (offs // self.block_size == block) + + self._log.debug("FilemapSeek: block_is_mapped(%d) returns %s" + % (block, result)) + return result + + def block_is_unmapped(self, block): + """Refer the '_FilemapBase' class for the documentation.""" + return not self.block_is_mapped(block) + + def _get_ranges(self, start, count, whence1, whence2): + """ + This function implements 'get_mapped_ranges()' and + 'get_unmapped_ranges()' depending on what is passed in the 'whence1' + and 'whence2' arguments. + """ + + assert whence1 != whence2 + end = start * self.block_size + limit = end + count * self.block_size + + while True: + start = _lseek(self._f_image, end, whence1) + if start == -1 or start >= limit or start == self.image_size: + break + + end = _lseek(self._f_image, start, whence2) + if end == -1 or end == self.image_size: + end = self.blocks_cnt * self.block_size + if end > limit: + end = limit + + start_blk = start // self.block_size + end_blk = end // self.block_size - 1 + self._log.debug("FilemapSeek: yielding range (%d, %d)" + % (start_blk, end_blk)) + yield (start_blk, end_blk) + + def get_mapped_ranges(self, start, count): + """Refer the '_FilemapBase' class for the documentation.""" + self._log.debug("FilemapSeek: get_mapped_ranges(%d, %d(%d))" + % (start, count, start + count - 1)) + return self._get_ranges(start, count, _SEEK_DATA, _SEEK_HOLE) + + def get_unmapped_ranges(self, start, count): + """Refer the '_FilemapBase' class for the documentation.""" + self._log.debug("FilemapSeek: get_unmapped_ranges(%d, %d(%d))" + % (start, count, start + count - 1)) + return self._get_ranges(start, count, _SEEK_HOLE, _SEEK_DATA) + + +# Below goes the FIEMAP ioctl implementation, which is not very readable +# because it deals with the rather complex FIEMAP ioctl. To understand the +# code, you need to know the FIEMAP interface, which is documented in the +# "Documentation/filesystems/fiemap.txt" file in the Linux kernel sources. + +# Format string for 'struct fiemap' +_FIEMAP_FORMAT = "=QQLLLL" +# sizeof(struct fiemap) +_FIEMAP_SIZE = struct.calcsize(_FIEMAP_FORMAT) +# Format string for 'struct fiemap_extent' +_FIEMAP_EXTENT_FORMAT = "=QQQQQLLLL" +# sizeof(struct fiemap_extent) +_FIEMAP_EXTENT_SIZE = struct.calcsize(_FIEMAP_EXTENT_FORMAT) +# The FIEMAP ioctl number +_FIEMAP_IOCTL = 0xC020660B +# This FIEMAP ioctl flag which instructs the kernel to sync the file before +# reading the block map +_FIEMAP_FLAG_SYNC = 0x00000001 +# Size of the buffer for 'struct fiemap_extent' elements which will be used +# when invoking the FIEMAP ioctl. The larger is the buffer, the less times the +# FIEMAP ioctl will be invoked. +_FIEMAP_BUFFER_SIZE = 256 * 1024 + +class FilemapFiemap(_FilemapBase): + """ + This class provides API to the FIEMAP ioctl. Namely, it allows to iterate + over all mapped blocks and over all holes. + + This class synchronizes the image file every time it invokes the FIEMAP + ioctl in order to work-around early FIEMAP implementation kernel bugs. + """ + + def __init__(self, image, log=None): + """ + Initialize a class instance. The 'image' argument is full the file + object to operate on. + """ + + # Call the base class constructor first + _FilemapBase.__init__(self, image, log) + self._log.debug("FilemapFiemap: initializing") + + self._buf_size = _FIEMAP_BUFFER_SIZE + + # Calculate how many 'struct fiemap_extent' elements fit the buffer + self._buf_size -= _FIEMAP_SIZE + self._fiemap_extent_cnt = self._buf_size // _FIEMAP_EXTENT_SIZE + assert self._fiemap_extent_cnt > 0 + self._buf_size = self._fiemap_extent_cnt * _FIEMAP_EXTENT_SIZE + self._buf_size += _FIEMAP_SIZE + + # Allocate a mutable buffer for the FIEMAP ioctl + self._buf = array.array('B', [0] * self._buf_size) + + # Check if the FIEMAP ioctl is supported + self.block_is_mapped(0) + + def _invoke_fiemap(self, block, count): + """ + Invoke the FIEMAP ioctl for 'count' blocks of the file starting from + block number 'block'. + + The full result of the operation is stored in 'self._buf' on exit. + Returns the unpacked 'struct fiemap' data structure in form of a python + list (just like 'struct.upack()'). + """ + + if self.blocks_cnt != 0 and (block < 0 or block >= self.blocks_cnt): + raise Error("bad block number %d, should be within [0, %d]" + % (block, self.blocks_cnt)) + + # Initialize the 'struct fiemap' part of the buffer. We use the + # '_FIEMAP_FLAG_SYNC' flag in order to make sure the file is + # synchronized. The reason for this is that early FIEMAP + # implementations had many bugs related to cached dirty data, and + # synchronizing the file is a necessary work-around. + struct.pack_into(_FIEMAP_FORMAT, self._buf, 0, block * self.block_size, + count * self.block_size, _FIEMAP_FLAG_SYNC, 0, + self._fiemap_extent_cnt, 0) + + try: + fcntl.ioctl(self._f_image, _FIEMAP_IOCTL, self._buf, 1) + except IOError as err: + # Note, the FIEMAP ioctl is supported by the Linux kernel starting + # from version 2.6.28 (year 2008). + if err.errno == os.errno.EOPNOTSUPP: + errstr = "FilemapFiemap: the FIEMAP ioctl is not supported " \ + "by the file-system" + self._log.debug(errstr) + raise ErrorNotSupp(errstr) + if err.errno == os.errno.ENOTTY: + errstr = "FilemapFiemap: the FIEMAP ioctl is not supported " \ + "by the kernel" + self._log.debug(errstr) + raise ErrorNotSupp(errstr) + raise Error("the FIEMAP ioctl failed for '%s': %s" + % (self._image_path, err)) + + return struct.unpack(_FIEMAP_FORMAT, self._buf[:_FIEMAP_SIZE]) + + def block_is_mapped(self, block): + """Refer the '_FilemapBase' class for the documentation.""" + struct_fiemap = self._invoke_fiemap(block, 1) + + # The 3rd element of 'struct_fiemap' is the 'fm_mapped_extents' field. + # If it contains zero, the block is not mapped, otherwise it is + # mapped. + result = bool(struct_fiemap[3]) + self._log.debug("FilemapFiemap: block_is_mapped(%d) returns %s" + % (block, result)) + return result + + def block_is_unmapped(self, block): + """Refer the '_FilemapBase' class for the documentation.""" + return not self.block_is_mapped(block) + + def _unpack_fiemap_extent(self, index): + """ + Unpack a 'struct fiemap_extent' structure object number 'index' from + the internal 'self._buf' buffer. + """ + + offset = _FIEMAP_SIZE + _FIEMAP_EXTENT_SIZE * index + return struct.unpack(_FIEMAP_EXTENT_FORMAT, + self._buf[offset : offset + _FIEMAP_EXTENT_SIZE]) + + def _do_get_mapped_ranges(self, start, count): + """ + Implements most the functionality for the 'get_mapped_ranges()' + generator: invokes the FIEMAP ioctl, walks through the mapped extents + and yields mapped block ranges. However, the ranges may be consecutive + (e.g., (1, 100), (100, 200)) and 'get_mapped_ranges()' simply merges + them. + """ + + block = start + while block < start + count: + struct_fiemap = self._invoke_fiemap(block, count) + + mapped_extents = struct_fiemap[3] + if mapped_extents == 0: + # No more mapped blocks + return + + extent = 0 + while extent < mapped_extents: + fiemap_extent = self._unpack_fiemap_extent(extent) + + # Start of the extent + extent_start = fiemap_extent[0] + # Starting block number of the extent + extent_block = extent_start // self.block_size + # Length of the extent + extent_len = fiemap_extent[2] + # Count of blocks in the extent + extent_count = extent_len // self.block_size + + # Extent length and offset have to be block-aligned + assert extent_start % self.block_size == 0 + assert extent_len % self.block_size == 0 + + if extent_block > start + count - 1: + return + + first = max(extent_block, block) + last = min(extent_block + extent_count, start + count) - 1 + yield (first, last) + + extent += 1 + + block = extent_block + extent_count + + def get_mapped_ranges(self, start, count): + """Refer the '_FilemapBase' class for the documentation.""" + self._log.debug("FilemapFiemap: get_mapped_ranges(%d, %d(%d))" + % (start, count, start + count - 1)) + iterator = self._do_get_mapped_ranges(start, count) + first_prev, last_prev = next(iterator) + + for first, last in iterator: + if last_prev == first - 1: + last_prev = last + else: + self._log.debug("FilemapFiemap: yielding range (%d, %d)" + % (first_prev, last_prev)) + yield (first_prev, last_prev) + first_prev, last_prev = first, last + + self._log.debug("FilemapFiemap: yielding range (%d, %d)" + % (first_prev, last_prev)) + yield (first_prev, last_prev) + + def get_unmapped_ranges(self, start, count): + """Refer the '_FilemapBase' class for the documentation.""" + self._log.debug("FilemapFiemap: get_unmapped_ranges(%d, %d(%d))" + % (start, count, start + count - 1)) + hole_first = start + for first, last in self._do_get_mapped_ranges(start, count): + if first > hole_first: + self._log.debug("FilemapFiemap: yielding range (%d, %d)" + % (hole_first, first - 1)) + yield (hole_first, first - 1) + + hole_first = last + 1 + + if hole_first < start + count: + self._log.debug("FilemapFiemap: yielding range (%d, %d)" + % (hole_first, start + count - 1)) + yield (hole_first, start + count - 1) + +def filemap(image, log=None): + """ + Create and return an instance of a Filemap class - 'FilemapFiemap' or + 'FilemapSeek', depending on what the system we run on supports. If the + FIEMAP ioctl is supported, an instance of the 'FilemapFiemap' class is + returned. Otherwise, if 'SEEK_HOLE' is supported an instance of the + 'FilemapSeek' class is returned. If none of these are supported, the + function generates an 'Error' type exception. + """ + + try: + return FilemapFiemap(image, log) + except ErrorNotSupp: + return FilemapSeek(image, log) + +def sparse_copy(src_fname, dst_fname, offset=0, skip=0, api=None): + """Efficiently copy sparse file to or into another file.""" + if not api: + api = filemap + fmap = api(src_fname) + try: + dst_file = open(dst_fname, 'r+b') + except IOError: + dst_file = open(dst_fname, 'wb') + dst_file.truncate(os.path.getsize(src_fname)) + + for first, last in fmap.get_mapped_ranges(0, fmap.blocks_cnt): + start = first * fmap.block_size + end = (last + 1) * fmap.block_size + + if start < skip < end: + fmap._f_image.seek(skip, os.SEEK_SET) + else: + fmap._f_image.seek(start, os.SEEK_SET) + dst_file.seek(offset + start, os.SEEK_SET) + + chunk_size = 1024 * 1024 + to_read = end - start + read = 0 + + while read < to_read: + if read + chunk_size > to_read: + chunk_size = to_read - read + chunk = fmap._f_image.read(chunk_size) + dst_file.write(chunk) + read += chunk_size + dst_file.close() diff --git a/scripts/lib/image/help.py b/scripts/lib/wic/help.py index 6e8e037c50..d6e027d253 100644 --- a/scripts/lib/image/help.py +++ b/scripts/lib/wic/help.py @@ -28,9 +28,12 @@ import subprocess import logging +from wic.pluginbase import PluginMgr, PLUGIN_TYPES + +logger = logging.getLogger('wic') def subcommand_error(args): - logging.info("invalid subcommand %s" % args[0]) + logger.info("invalid subcommand %s", args[0]) def display_help(subcommand, subcommands): @@ -40,9 +43,11 @@ def display_help(subcommand, subcommands): if subcommand not in subcommands: return False - help = subcommands.get(subcommand, subcommand_error)[2] + hlp = subcommands.get(subcommand, subcommand_error)[2] + if callable(hlp): + hlp = hlp() pager = subprocess.Popen('less', stdin=subprocess.PIPE) - pager.communicate(help) + pager.communicate(hlp.encode('utf-8')) return True @@ -55,19 +60,38 @@ def wic_help(args, usage_str, subcommands): print(usage_str) +def get_wic_plugins_help(): + """ + Combine wic_plugins_help with the help for every known + source plugin. + """ + result = wic_plugins_help + for plugin_type in PLUGIN_TYPES: + result += '\n\n%s PLUGINS\n\n' % plugin_type.upper() + for name, plugin in PluginMgr.get_plugins(plugin_type).items(): + result += "\n %s plugin:\n" % name + if plugin.__doc__: + result += plugin.__doc__ + else: + result += "\n %s is missing docstring\n" % plugin + return result + + def invoke_subcommand(args, parser, main_command_usage, subcommands): """ Dispatch to subcommand handler borrowed from combo-layer. Should use argparse, but has to work in 2.6. """ if not args: - logging.error("No subcommand specified, exiting") + logger.error("No subcommand specified, exiting") parser.print_help() + return 1 elif args[0] == "help": wic_help(args, main_command_usage, subcommands) elif args[0] not in subcommands: - logging.error("Unsupported subcommand %s, exiting\n" % (args[0])) + logger.error("Unsupported subcommand %s, exiting\n", args[0]) parser.print_help() + return 1 else: usage = subcommands.get(args[0], subcommand_error)[1] subcommands.get(args[0], subcommand_error)[0](args[1:], usage) @@ -81,19 +105,17 @@ wic_usage = """ Create a customized OpenEmbedded image - usage: wic [--version] [--help] COMMAND [ARGS] + usage: wic [--version] | [--help] | [COMMAND [ARGS]] Current 'wic' commands are: + help Show help for command or one of the topics (see below) create Create a new OpenEmbedded image - list List available values for options and image properties + list List available canned images and source plugins Help topics: - overview wic overview - General overview of wic - plugins wic plugins - Overview and API - kickstart wic kickstart - wic kickstart reference - - See 'wic help <COMMAND or HELP TOPIC>' for more information on a specific - command or help topic. + overview wic overview - General overview of wic + plugins wic plugins - Overview and API + kickstart wic kickstart - wic kickstart reference """ wic_help_usage = """ @@ -109,8 +131,9 @@ wic_create_usage = """ usage: wic create <wks file or image name> [-o <DIRNAME> | --outdir <DIRNAME>] [-i <JSON PROPERTY FILE> | --infile <JSON PROPERTY_FILE>] - [-e | --image-name] [-r, --rootfs-dir] [-b, --bootimg-dir] - [-k, --kernel-dir] [-n, --native-sysroot] [-s, --skip-build-check] + [-e | --image-name] [-s, --skip-build-check] [-D, --debug] + [-r, --rootfs-dir] [-b, --bootimg-dir] + [-k, --kernel-dir] [-n, --native-sysroot] [-f, --build-rootfs] This command creates an OpenEmbedded image based on the 'OE kickstart commands' found in the <wks file>. @@ -128,9 +151,10 @@ NAME SYNOPSIS wic create <wks file or image name> [-o <DIRNAME> | --outdir <DIRNAME>] - [-i <JSON PROPERTY FILE> | --infile <JSON PROPERTY_FILE>] - [-e | --image-name] [-r, --rootfs-dir] [-b, --bootimg-dir] - [-k, --kernel-dir] [-n, --native-sysroot] [-s, --skip-build-check] + [-e | --image-name] [-s, --skip-build-check] [-D, --debug] + [-r, --rootfs-dir] [-b, --bootimg-dir] + [-k, --kernel-dir] [-n, --native-sysroot] [-f, --build-rootfs] + [-c, --compress-with] [-m, --bmap] DESCRIPTION This command creates an OpenEmbedded image based on the 'OE @@ -144,7 +168,7 @@ DESCRIPTION the corresponding artifacts are typically found in a normal OpenEmbedded build. - Alternatively, users can use the -e option to have 'mic' determine + Alternatively, users can use the -e option to have 'wic' determine those locations for a given image. If the -e option is used, the user needs to have set the appropriate MACHINE variable in local.conf, and have sourced the build environment. @@ -165,6 +189,8 @@ DESCRIPTION The -n option is used to specify the path to the native sysroot containing the tools to use to build the image. + The -f option is used to build rootfs by running "bitbake <image>" + The -s option is used to skip the build check. The build check is a simple sanity check used to determine whether the user has sourced the build environment so that the -e option can operate @@ -172,6 +198,12 @@ DESCRIPTION explicitly, 'wic' assumes the user knows what he or she is doing and skips the build check. + The -D option is used to display debug information detailing + exactly what happens behind the scenes when a create request is + fulfilled (or not, as the case may be). It enumerates and + displays the command sequence used, and should be included in any + bug report describing unexpected results. + When 'wic -e' is used, the locations for the build artifacts values are determined by 'wic -e' from the output of the 'bitbake -e' command given an image name e.g. 'core-image-minimal' and a @@ -181,7 +213,7 @@ DESCRIPTION -r: IMAGE_ROOTFS -k: STAGING_KERNEL_DIR -n: STAGING_DIR_NATIVE - -b: HDDDIR and STAGING_DATA_DIR (handlers decide which to use) + -b: empty (plugin-specific handlers must determine this) If 'wic -e' is not used, the user needs to select the appropriate value for -b (as well as -r, -k, and -n). @@ -189,32 +221,24 @@ DESCRIPTION The -o option can be used to place the image in a directory with a different name and location. - As an alternative to the wks file, the image-specific properties - that define the values that will be used to generate a particular - image can be specified on the command-line using the -i option and - supplying a JSON object consisting of the set of name:value pairs - needed by image creation. + The -c option is used to specify compressor utility to compress + an image. gzip, bzip2 and xz compressors are supported. - The set of properties available for a given image type can be - listed using the 'wic list' command. + The -m option is used to produce .bmap file for the image. This file + can be used to flash image using bmaptool utility. """ wic_list_usage = """ - List available OpenEmbedded image properties and values + List available OpenEmbedded images and source plugins usage: wic list images wic list <image> help wic list source-plugins - wic list properties - wic list properties <wks file> - wic list property <property> - [-o <JSON PROPERTY FILE> | --outfile <JSON PROPERTY_FILE>] This command enumerates the set of available canned images as well as - help for those images. It also can be used to enumerate the complete - set of possible values for a specified option or property needed by - the image creation process. + help for those images. It also can be used to list of available source + plugins. The first form enumerates all the available 'canned' images. @@ -224,44 +248,27 @@ wic_list_usage = """ The third form enumerates all the available --sources (source plugins). - The fourth form enumerates all the possible values that exist and can - be specified in an OE kickstart (wks) file. - - The fifth form enumerates all the possible options that exist for the - set of properties specified in a given OE kickstart (ks) file. - - The final form enumerates all the possible values that exist and can - be specified for any given OE kickstart (wks) property. - See 'wic help list' for more details. """ wic_list_help = """ NAME - wic list - List available OpenEmbedded image properties and values + wic list - List available OpenEmbedded images and source plugins SYNOPSIS wic list images wic list <image> help wic list source-plugins - wic list properties - wic list properties <wks file> - wic list property <property> - [-o <JSON PROPERTY FILE> | --outfile <JSON PROPERTY_FILE>] DESCRIPTION - This command enumerates the complete set of possible values for a - specified option or property needed by the image creation process. - This command enumerates the set of available canned images as well - as help for those images. It also can be used to enumerate the - complete set of possible values for a specified option or property - needed by the image creation process. + as help for those images. It also can be used to list available + source plugins. The first form enumerates all the available 'canned' images. These are actually just the set of .wks files that have been moved - into the /scripts/lib/image/canned-wks directory). + into the /scripts/lib/wic/canned-wks directory). The second form lists the detailed help information for a specific 'canned' image. @@ -274,60 +281,6 @@ DESCRIPTION sources listed by the 'list source-plugins' command. Users can also add their own source plugins - see 'wic help plugins' for details. - - The third form enumerates all the possible values that exist and - can be specified in a OE kickstart (wks) file. The output of this - can be used by the third form to print the description and - possible values of a specific property. - - The fourth form enumerates all the possible options that exist for - the set of properties specified in a given OE kickstart (wks) - file. If the -o option is specified, the list of properties, in - addition to being displayed, will be written to the specified file - as a JSON object. In this case, the object will consist of the - set of name:value pairs corresponding to the (possibly nested) - dictionary of properties defined by the input statements used by - the image. Some example output for the 'list <wks file>' command: - - $ wic list test.ks - "part" : { - "mountpoint" : "/" - "fstype" : "ext3" - } - "part" : { - "mountpoint" : "/home" - "fstype" : "ext3" - "offset" : "10000" - } - "bootloader" : { - "type" : "efi" - } - . - . - . - - Each entry in the output consists of the name of the input element - e.g. "part", followed by the properties defined for that - element enclosed in braces. This information should provide - sufficient information to create a complete user interface with. - - The final form enumerates all the possible values that exist and - can be specified for any given OE kickstart (wks) property. If - the -o option is specified, the list of values for the given - property, in addition to being displayed, will be written to the - specified file as a JSON object. In this case, the object will - consist of the set of name:value pairs corresponding to the array - of property values associated with the property. - - $ wic list property part - ["mountpoint", "where the partition should be mounted"] - ["fstype", "filesytem type of the partition"] - ["ext3"] - ["ext4"] - ["btrfs"] - ["swap"] - ["offset", "offset of the partition within the image"] - """ wic_plugins_help = """ @@ -349,12 +302,12 @@ DESCRIPTION implementation that populates a corresponding partition. A source plugin is created as a subclass of SourcePlugin (see - scripts/lib/mic/pluginbase.py) and the plugin file containing it - is added to scripts/lib/mic/plugins/source/ to make the plugin + scripts/lib/wic/pluginbase.py) and the plugin file containing it + is added to scripts/lib/wic/plugins/source/ to make the plugin implementation available to the wic implementation. Source plugins can also be implemented and added by external - layers - any plugins found in a scripts/lib/mic/plugins/source/ + layers - any plugins found in a scripts/lib/wic/plugins/source/ directory in an external layer will also be made available. When the wic implementation needs to invoke a partition-specific @@ -420,12 +373,7 @@ DESCRIPTION This scheme is extensible - adding more hooks is a simple matter of adding more plugin methods to SourcePlugin and derived classes. - The code that then needs to call the plugin methods uses - plugin.get_source_plugin_methods() to find the method(s) needed by - the call; this is done by filling up a dict with keys containing - the method names of interest - on success, these will be filled in - with the actual methods. Please see the implementation for - examples and details. + Please see the implementation for details. """ wic_overview_help = """ @@ -456,24 +404,12 @@ DESCRIPTION oe-core: directdisk.bbclass and mkefidisk.sh. The difference between wic and those examples is that with wic the functionality of those scripts is implemented by a general-purpose partitioning - 'language' based on Redhat kickstart syntax (with the underlying - code borrowed from Tizen mic, which in turn was borrowed from - Meego mic, in turn borrowed from Fedora livecd, etc.). + 'language' based on Redhat kickstart syntax). The initial motivation and design considerations that lead to the current tool are described exhaustively in Yocto Bug #3847 (https://bugzilla.yoctoproject.org/show_bug.cgi?id=3847). - Though the current wic tool only uses the kickstart syntax related - to partitioning and bootloaders and only for creating images, - because the code is based on the mic/pykickstart code, future - deployment efforts such as those partially described by Yocto Bug - #4106 (https://bugzilla.yoctoproject.org/show_bug.cgi?id=4106), - but also others including package selection (from e.g. binary - feeds) and deployment configuration of users/network/services, - etc, could be implemented under this framework, considering that - all of those are implemented in some form by the base system. - Implementation and Examples wic can be used in two different modes, depending on how much @@ -531,8 +467,9 @@ DESCRIPTION usage: wic create <wks file or image name> [-o <DIRNAME> | ...] [-i <JSON PROPERTY FILE> | --infile <JSON PROPERTY_FILE>] - [-e | --image-name] [-r, --rootfs-dir] [-b, --bootimg-dir] - [-k, --kernel-dir] [-n, --native-sysroot] [-s, --skip-build-check] + [-e | --image-name] [-s, --skip-build-check] [-D, --debug] + [-r, --rootfs-dir] [-b, --bootimg-dir] [-k, --kernel-dir] + [-n, --native-sysroot] [-f, --build-rootfs] This command creates an OpenEmbedded image based on the 'OE kickstart commands' found in the <wks file>. @@ -575,7 +512,7 @@ DESCRIPTION NATIVE_SYSROOT: ... The image(s) were created using OE kickstart file: - .../scripts/lib/image/canned-wks/directdisk.wks + .../scripts/lib/wic/canned-wks/directdisk.wks The output shows the name and location of the image created, and so that you know exactly what was used to generate the image, each @@ -602,18 +539,33 @@ DESCRIPTION and also uses the -o option to have wic create the output somewhere other than the default /var/tmp/wic: - $ wic create ~/test.wks -o /home/trz/testwic --rootfs-dir - /home/trz/yocto/build/tmp/work/crownbay/core-image-minimal/1.0-r0/rootfs - --bootimg-dir /home/trz/yocto/build/tmp/sysroots/crownbay/usr/share - --kernel-dir /home/trz/yocto/build/tmp/sysroots/crownbay/usr/src/kernel - --native-sysroot /home/trz/yocto/build/tmp/sysroots/x86_64-linux + $ wic create ./test.wks -o ./out --rootfs-dir + tmp/work/qemux86_64-poky-linux/core-image-minimal/1.0-r0/rootfs + --bootimg-dir tmp/sysroots/qemux86-64/usr/share + --kernel-dir tmp/deploy/images/qemux86-64 + --native-sysroot tmp/sysroots/x86_64-linux - Creating image(s)... + Creating image(s)... - Info: The new image(s) can be found here: - /home/trz/testwic/build/test-201309260032-sda.direct + Info: The new image(s) can be found here: + out/build/test-201507211313-sda.direct + + The following build artifacts were used to create the image(s): + ROOTFS_DIR: tmp/work/qemux86_64-poky-linux/core-image-minimal/1.0-r0/rootfs + BOOTIMG_DIR: tmp/sysroots/qemux86-64/usr/share + KERNEL_DIR: tmp/deploy/images/qemux86-64 + NATIVE_SYSROOT: tmp/sysroots/x86_64-linux + + The image(s) were created using OE kickstart file: + ./test.wks + + Here is a content of test.wks: + + part /boot --source bootimg-pcbios --ondisk sda --label boot --active --align 1024 + part / --source rootfs --ondisk sda --fstype=ext3 --label platform --align 1024 + + bootloader --timeout=0 --append="rootwait rootfstype=ext3 video=vesafb vga=0x318 console=tty0" - ... Finally, here's an example of the actual partition language commands used to generate the mkefidisk image i.e. these are the @@ -665,7 +617,7 @@ DESCRIPTION This command creates a partition on the system and uses the following syntax: - part <mountpoint> + part [<mountpoint>] The <mountpoint> is where the partition will be mounted and must take of one of the following forms: @@ -674,12 +626,28 @@ DESCRIPTION swap: The partition will be used as swap space. + If a <mountpoint> is not specified the partition will be created + but will not be mounted. + + Partitions with a <mountpoint> specified will be automatically mounted. + This is achieved by wic adding entries to the fstab during image + generation. In order for a valid fstab to be generated one of the + --ondrive, --ondisk or --use-uuid partition options must be used for + each partition that specifies a mountpoint. + + The following are supported 'part' options: - --size: The minimum partition size in MBytes. Specify an - integer value such as 500. Do not append the number - with "MB". You do not need this option if you use - --source. + --size: The minimum partition size. Specify an integer value + such as 500. Multipliers k, M ang G can be used. If + not specified, the size is in MB. + You do not need this option if you use --source. + + --fixed-size: Exact partition size. Value format is the same + as for --size option. This option cannot be + specified along with --size. If partition data + is larger than --fixed-size and error will be + raised when assembling disk image. --source: This option is a wic-specific option that names the source of the data that will populate the @@ -708,6 +676,10 @@ DESCRIPTION up being are dependent on the given plugin implementation. + If --source option is not used, the wic command + will create empty partition. --size parameter has + to be used to specify size of empty partition. + --ondisk or --ondrive: Forces the partition to be created on a particular disk. @@ -715,6 +687,8 @@ DESCRIPTION apply to partitions created using '--source rootfs' (see --source above). Valid values are: + vfat + msdos ext2 ext3 ext4 @@ -740,6 +714,50 @@ DESCRIPTION to start a partition on an x KBytes boundary. + --no-table: This option is specific to wic. Space will be + reserved for the partition and it will be + populated but it will not be added to the + partition table. It may be useful for + bootloaders. + + --exclude-path: This option is specific to wic. It excludes the given + relative path from the resulting image. If the path + ends with a slash, only the content of the directory + is omitted, not the directory itself. This option only + has an effect with the rootfs source plugin. + + --extra-space: This option is specific to wic. It adds extra + space after the space filled by the content + of the partition. The final size can go + beyond the size specified by --size. + By default, 10MB. This option cannot be used + with --fixed-size option. + + --overhead-factor: This option is specific to wic. The + size of the partition is multiplied by + this factor. It has to be greater than or + equal to 1. The default value is 1.3. + This option cannot be used with --fixed-size + option. + + --part-type: This option is specific to wic. It specifies partition + type GUID for GPT partitions. + List of partition type GUIDS can be found here: + http://en.wikipedia.org/wiki/GUID_Partition_Table#Partition_type_GUIDs + + --use-uuid: This option is specific to wic. It makes wic to generate + random globally unique identifier (GUID) for the partition + and use it in bootloader configuration to specify root partition. + + --uuid: This option is specific to wic. It specifies partition UUID. + It's useful if preconfigured partition UUID is added to kernel command line + in bootloader configuration before running wic. In this case .wks file can + be generated or modified to set preconfigured parition UUID using this option. + + --system-id: This option is specific to wic. It specifies partition system id. It's useful + for the harware that requires non-default partition system ids. The parameter + in one byte long hex number either with 0x prefix or without it. + * bootloader This command allows the user to specify various bootloader @@ -752,8 +770,28 @@ DESCRIPTION bootloader command-line - for example, the syslinux APPEND or grub kernel command line. + --configfile: Specifies a user defined configuration file for + the bootloader. This file must be located in the + canned-wks folder or could be the full path to the + file. Using this option will override any other + bootloader option. + Note that bootloader functionality and boot partitions are implemented by the various --source plugins that implement bootloader functionality; the bootloader command essentially provides a means of modifying bootloader configuration. + + * include + + This command allows the user to include the content of .wks file + into original .wks file. + + Command uses the following syntax: + + include <file> + + The <file> is either path to the file or its name. If name is + specified wic will try to find file in the directories with canned + .wks files. + """ diff --git a/scripts/lib/wic/ksparser.py b/scripts/lib/wic/ksparser.py new file mode 100644 index 0000000000..d026caad0f --- /dev/null +++ b/scripts/lib/wic/ksparser.py @@ -0,0 +1,227 @@ +#!/usr/bin/env python -tt +# ex:ts=4:sw=4:sts=4:et +# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- +# +# Copyright (c) 2016 Intel, Inc. +# +# This program is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by the Free +# Software Foundation; version 2 of the License +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY +# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., 59 +# Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# DESCRIPTION +# This module provides parser for kickstart format +# +# AUTHORS +# Ed Bartosh <ed.bartosh> (at] linux.intel.com> + +"""Kickstart parser module.""" + +import os +import shlex +import logging + +from argparse import ArgumentParser, ArgumentError, ArgumentTypeError + +from wic.engine import find_canned +from wic.partition import Partition + +logger = logging.getLogger('wic') + +class KickStartError(Exception): + """Custom exception.""" + pass + +class KickStartParser(ArgumentParser): + """ + This class overwrites error method to throw exception + instead of producing usage message(default argparse behavior). + """ + def error(self, message): + raise ArgumentError(None, message) + +def sizetype(arg): + """ + Custom type for ArgumentParser + Converts size string in <num>[K|k|M|G] format into the integer value + """ + if arg.isdigit(): + return int(arg) * 1024 + + if not arg[:-1].isdigit(): + raise ArgumentTypeError("Invalid size: %r" % arg) + + size = int(arg[:-1]) + if arg.endswith("k") or arg.endswith("K"): + return size + if arg.endswith("M"): + return size * 1024 + if arg.endswith("G"): + return size * 1024 * 1024 + + raise ArgumentTypeError("Invalid size: %r" % arg) + +def overheadtype(arg): + """ + Custom type for ArgumentParser + Converts overhead string to float and checks if it's bigger than 1.0 + """ + try: + result = float(arg) + except ValueError: + raise ArgumentTypeError("Invalid value: %r" % arg) + + if result < 1.0: + raise ArgumentTypeError("Overhead factor should be > 1.0" % arg) + + return result + +def cannedpathtype(arg): + """ + Custom type for ArgumentParser + Tries to find file in the list of canned wks paths + """ + scripts_path = os.path.abspath(os.path.dirname(__file__) + '../../..') + result = find_canned(scripts_path, arg) + if not result: + raise ArgumentTypeError("file not found: %s" % arg) + return result + +def systemidtype(arg): + """ + Custom type for ArgumentParser + Checks if the argument sutisfies system id requirements, + i.e. if it's one byte long integer > 0 + """ + error = "Invalid system type: %s. must be hex "\ + "between 0x1 and 0xFF" % arg + try: + result = int(arg, 16) + except ValueError: + raise ArgumentTypeError(error) + + if result <= 0 or result > 0xff: + raise ArgumentTypeError(error) + + return arg + +class KickStart(): + """"Kickstart parser implementation.""" + + DEFAULT_EXTRA_SPACE = 10*1024 + DEFAULT_OVERHEAD_FACTOR = 1.3 + + def __init__(self, confpath): + + self.partitions = [] + self.bootloader = None + self.lineno = 0 + self.partnum = 0 + + parser = KickStartParser() + subparsers = parser.add_subparsers() + + part = subparsers.add_parser('part') + part.add_argument('mountpoint', nargs='?') + part.add_argument('--active', action='store_true') + part.add_argument('--align', type=int) + part.add_argument('--exclude-path', nargs='+') + part.add_argument("--extra-space", type=sizetype) + part.add_argument('--fsoptions', dest='fsopts') + part.add_argument('--fstype', default='vfat', + choices=('ext2', 'ext3', 'ext4', 'btrfs', + 'squashfs', 'vfat', 'msdos', 'swap')) + part.add_argument('--label') + part.add_argument('--no-table', action='store_true') + part.add_argument('--ondisk', '--ondrive', dest='disk', default='sda') + part.add_argument("--overhead-factor", type=overheadtype) + part.add_argument('--part-type') + part.add_argument('--rootfs-dir') + + # --size and --fixed-size cannot be specified together; options + # ----extra-space and --overhead-factor should also raise a parser + # --error, but since nesting mutually exclusive groups does not work, + # ----extra-space/--overhead-factor are handled later + sizeexcl = part.add_mutually_exclusive_group() + sizeexcl.add_argument('--size', type=sizetype, default=0) + sizeexcl.add_argument('--fixed-size', type=sizetype, default=0) + + part.add_argument('--source') + part.add_argument('--sourceparams') + part.add_argument('--system-id', type=systemidtype) + part.add_argument('--use-uuid', action='store_true') + part.add_argument('--uuid') + + bootloader = subparsers.add_parser('bootloader') + bootloader.add_argument('--append') + bootloader.add_argument('--configfile') + bootloader.add_argument('--ptable', choices=('msdos', 'gpt'), + default='msdos') + bootloader.add_argument('--timeout', type=int) + bootloader.add_argument('--source') + + include = subparsers.add_parser('include') + include.add_argument('path', type=cannedpathtype) + + self._parse(parser, confpath) + if not self.bootloader: + logger.warning('bootloader config not specified, using defaults\n') + self.bootloader = bootloader.parse_args([]) + + def _parse(self, parser, confpath): + """ + Parse file in .wks format using provided parser. + """ + with open(confpath) as conf: + lineno = 0 + for line in conf: + line = line.strip() + lineno += 1 + if line and line[0] != '#': + try: + line_args = shlex.split(line) + parsed = parser.parse_args(line_args) + except ArgumentError as err: + raise KickStartError('%s:%d: %s' % \ + (confpath, lineno, err)) + if line.startswith('part'): + # using ArgumentParser one cannot easily tell if option + # was passed as argument, if said option has a default + # value; --overhead-factor/--extra-space cannot be used + # with --fixed-size, so at least detect when these were + # passed with non-0 values ... + if parsed.fixed_size: + if parsed.overhead_factor or parsed.extra_space: + err = "%s:%d: arguments --overhead-factor and --extra-space not "\ + "allowed with argument --fixed-size" \ + % (confpath, lineno) + raise KickStartError(err) + else: + # ... and provide defaults if not using + # --fixed-size iff given option was not used + # (again, one cannot tell if option was passed but + # with value equal to 0) + if '--overhead-factor' not in line_args: + parsed.overhead_factor = self.DEFAULT_OVERHEAD_FACTOR + if '--extra-space' not in line_args: + parsed.extra_space = self.DEFAULT_EXTRA_SPACE + + self.partnum += 1 + self.partitions.append(Partition(parsed, self.partnum)) + elif line.startswith('include'): + self._parse(parser, parsed.path) + elif line.startswith('bootloader'): + if not self.bootloader: + self.bootloader = parsed + else: + err = "%s:%d: more than one bootloader specified" \ + % (confpath, lineno) + raise KickStartError(err) diff --git a/scripts/lib/wic/partition.py b/scripts/lib/wic/partition.py new file mode 100644 index 0000000000..939e66731b --- /dev/null +++ b/scripts/lib/wic/partition.py @@ -0,0 +1,411 @@ +# ex:ts=4:sw=4:sts=4:et +# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- +# +# Copyright (c) 2013-2016 Intel Corporation. +# All rights reserved. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +# +# DESCRIPTION +# This module provides the OpenEmbedded partition object definitions. +# +# AUTHORS +# Tom Zanussi <tom.zanussi (at] linux.intel.com> +# Ed Bartosh <ed.bartosh> (at] linux.intel.com> + +import logging +import os +import tempfile + +from wic import WicError +from wic.utils.misc import exec_cmd, exec_native_cmd, get_bitbake_var +from wic.pluginbase import PluginMgr + +logger = logging.getLogger('wic') + +class Partition(): + + def __init__(self, args, lineno): + self.args = args + self.active = args.active + self.align = args.align + self.disk = args.disk + self.device = None + self.extra_space = args.extra_space + self.exclude_path = args.exclude_path + self.fsopts = args.fsopts + self.fstype = args.fstype + self.label = args.label + self.mountpoint = args.mountpoint + self.no_table = args.no_table + self.num = None + self.overhead_factor = args.overhead_factor + self.part_type = args.part_type + self.rootfs_dir = args.rootfs_dir + self.size = args.size + self.fixed_size = args.fixed_size + self.source = args.source + self.sourceparams = args.sourceparams + self.system_id = args.system_id + self.use_uuid = args.use_uuid + self.uuid = args.uuid + + self.lineno = lineno + self.source_file = "" + self.sourceparams_dict = {} + + def get_extra_block_count(self, current_blocks): + """ + The --size param is reflected in self.size (in kB), and we already + have current_blocks (1k) blocks, calculate and return the + number of (1k) blocks we need to add to get to --size, 0 if + we're already there or beyond. + """ + logger.debug("Requested partition size for %s: %d", + self.mountpoint, self.size) + + if not self.size: + return 0 + + requested_blocks = self.size + + logger.debug("Requested blocks %d, current_blocks %d", + requested_blocks, current_blocks) + + if requested_blocks > current_blocks: + return requested_blocks - current_blocks + else: + return 0 + + def get_rootfs_size(self, actual_rootfs_size=0): + """ + Calculate the required size of rootfs taking into consideration + --size/--fixed-size flags as well as overhead and extra space, as + specified in kickstart file. Raises an error if the + `actual_rootfs_size` is larger than fixed-size rootfs. + + """ + if self.fixed_size: + rootfs_size = self.fixed_size + if actual_rootfs_size > rootfs_size: + raise WicError("Actual rootfs size (%d kB) is larger than " + "allowed size %d kB" % + (actual_rootfs_size, rootfs_size)) + else: + extra_blocks = self.get_extra_block_count(actual_rootfs_size) + if extra_blocks < self.extra_space: + extra_blocks = self.extra_space + + rootfs_size = actual_rootfs_size + extra_blocks + rootfs_size *= self.overhead_factor + + logger.debug("Added %d extra blocks to %s to get to %d total blocks", + extra_blocks, self.mountpoint, rootfs_size) + + return rootfs_size + + @property + def disk_size(self): + """ + Obtain on-disk size of partition taking into consideration + --size/--fixed-size options. + + """ + return self.fixed_size if self.fixed_size else self.size + + def prepare(self, creator, cr_workdir, oe_builddir, rootfs_dir, + bootimg_dir, kernel_dir, native_sysroot): + """ + Prepare content for individual partitions, depending on + partition command parameters. + """ + if not self.source: + if not self.size and not self.fixed_size: + raise WicError("The %s partition has a size of zero. Please " + "specify a non-zero --size/--fixed-size for that " + "partition." % self.mountpoint) + + if self.fstype == "swap": + self.prepare_swap_partition(cr_workdir, oe_builddir, + native_sysroot) + self.source_file = "%s/fs.%s" % (cr_workdir, self.fstype) + else: + if self.fstype == 'squashfs': + raise WicError("It's not possible to create empty squashfs " + "partition '%s'" % (self.mountpoint)) + + rootfs = "%s/fs_%s.%s.%s" % (cr_workdir, self.label, + self.lineno, self.fstype) + if os.path.isfile(rootfs): + os.remove(rootfs) + + prefix = "ext" if self.fstype.startswith("ext") else self.fstype + method = getattr(self, "prepare_empty_partition_" + prefix) + method(rootfs, oe_builddir, native_sysroot) + self.source_file = rootfs + return + + plugins = PluginMgr.get_plugins('source') + + if self.source not in plugins: + raise WicError("The '%s' --source specified for %s doesn't exist.\n\t" + "See 'wic list source-plugins' for a list of available" + " --sources.\n\tSee 'wic help source-plugins' for " + "details on adding a new source plugin." % + (self.source, self.mountpoint)) + + srcparams_dict = {} + if self.sourceparams: + # Split sourceparams string of the form key1=val1[,key2=val2,...] + # into a dict. Also accepts valueless keys i.e. without = + splitted = self.sourceparams.split(',') + srcparams_dict = dict(par.split('=') for par in splitted if par) + + plugin = PluginMgr.get_plugins('source')[self.source] + plugin.do_configure_partition(self, srcparams_dict, creator, + cr_workdir, oe_builddir, bootimg_dir, + kernel_dir, native_sysroot) + plugin.do_stage_partition(self, srcparams_dict, creator, + cr_workdir, oe_builddir, bootimg_dir, + kernel_dir, native_sysroot) + plugin.do_prepare_partition(self, srcparams_dict, creator, + cr_workdir, oe_builddir, bootimg_dir, + kernel_dir, rootfs_dir, native_sysroot) + + # further processing required Partition.size to be an integer, make + # sure that it is one + if not isinstance(self.size, int): + raise WicError("Partition %s internal size is not an integer. " + "This a bug in source plugin %s and needs to be fixed." % + (self.mountpoint, self.source)) + + if self.fixed_size and self.size > self.fixed_size: + raise WicError("File system image of partition %s is " + "larger (%d kB) than its allowed size %d kB" % + (self.mountpoint, self.size, self.fixed_size)) + + def prepare_rootfs(self, cr_workdir, oe_builddir, rootfs_dir, + native_sysroot): + """ + Prepare content for a rootfs partition i.e. create a partition + and fill it from a /rootfs dir. + + Currently handles ext2/3/4, btrfs and vfat. + """ + p_prefix = os.environ.get("PSEUDO_PREFIX", "%s/usr" % native_sysroot) + p_localstatedir = os.environ.get("PSEUDO_LOCALSTATEDIR", + "%s/../pseudo" % rootfs_dir) + p_passwd = os.environ.get("PSEUDO_PASSWD", rootfs_dir) + p_nosymlinkexp = os.environ.get("PSEUDO_NOSYMLINKEXP", "1") + pseudo = "export PSEUDO_PREFIX=%s;" % p_prefix + pseudo += "export PSEUDO_LOCALSTATEDIR=%s;" % p_localstatedir + pseudo += "export PSEUDO_PASSWD=%s;" % p_passwd + pseudo += "export PSEUDO_NOSYMLINKEXP=%s;" % p_nosymlinkexp + pseudo += "%s " % get_bitbake_var("FAKEROOTCMD") + + rootfs = "%s/rootfs_%s.%s.%s" % (cr_workdir, self.label, + self.lineno, self.fstype) + if os.path.isfile(rootfs): + os.remove(rootfs) + + # Get rootfs size from bitbake variable if it's not set in .ks file + if not self.size: + # Bitbake variable ROOTFS_SIZE is calculated in + # Image._get_rootfs_size method from meta/lib/oe/image.py + # using IMAGE_ROOTFS_SIZE, IMAGE_ROOTFS_ALIGNMENT, + # IMAGE_OVERHEAD_FACTOR and IMAGE_ROOTFS_EXTRA_SPACE + rsize_bb = get_bitbake_var('ROOTFS_SIZE') + if rsize_bb: + logger.warning('overhead-factor was specified, but size was not,' + ' so bitbake variables will be used for the size.' + ' In this case both IMAGE_OVERHEAD_FACTOR and ' + '--overhead-factor will be applied') + self.size = int(round(float(rsize_bb))) + + prefix = "ext" if self.fstype.startswith("ext") else self.fstype + method = getattr(self, "prepare_rootfs_" + prefix) + method(rootfs, oe_builddir, rootfs_dir, native_sysroot, pseudo) + self.source_file = rootfs + + # get the rootfs size in the right units for kickstart (kB) + du_cmd = "du -Lbks %s" % rootfs + out = exec_cmd(du_cmd) + self.size = int(out.split()[0]) + + def prepare_rootfs_ext(self, rootfs, oe_builddir, rootfs_dir, + native_sysroot, pseudo): + """ + Prepare content for an ext2/3/4 rootfs partition. + """ + du_cmd = "du -ks %s" % rootfs_dir + out = exec_cmd(du_cmd) + actual_rootfs_size = int(out.split()[0]) + + rootfs_size = self.get_rootfs_size(actual_rootfs_size) + + with open(rootfs, 'w') as sparse: + os.ftruncate(sparse.fileno(), rootfs_size * 1024) + + extra_imagecmd = "-i 8192" + + label_str = "" + if self.label: + label_str = "-L %s" % self.label + + mkfs_cmd = "mkfs.%s -F %s %s %s -d %s" % \ + (self.fstype, extra_imagecmd, rootfs, label_str, rootfs_dir) + exec_native_cmd(mkfs_cmd, native_sysroot, pseudo=pseudo) + + mkfs_cmd = "fsck.%s -pvfD %s" % (self.fstype, rootfs) + exec_native_cmd(mkfs_cmd, native_sysroot, pseudo=pseudo) + + def prepare_rootfs_btrfs(self, rootfs, oe_builddir, rootfs_dir, + native_sysroot, pseudo): + """ + Prepare content for a btrfs rootfs partition. + + Currently handles ext2/3/4 and btrfs. + """ + du_cmd = "du -ks %s" % rootfs_dir + out = exec_cmd(du_cmd) + actual_rootfs_size = int(out.split()[0]) + + rootfs_size = self.get_rootfs_size(actual_rootfs_size) + + with open(rootfs, 'w') as sparse: + os.ftruncate(sparse.fileno(), rootfs_size * 1024) + + label_str = "" + if self.label: + label_str = "-L %s" % self.label + + mkfs_cmd = "mkfs.%s -b %d -r %s %s %s" % \ + (self.fstype, rootfs_size * 1024, rootfs_dir, label_str, rootfs) + exec_native_cmd(mkfs_cmd, native_sysroot, pseudo=pseudo) + + def prepare_rootfs_msdos(self, rootfs, oe_builddir, rootfs_dir, + native_sysroot, pseudo): + """ + Prepare content for a msdos/vfat rootfs partition. + """ + du_cmd = "du -bks %s" % rootfs_dir + out = exec_cmd(du_cmd) + blocks = int(out.split()[0]) + + rootfs_size = self.get_rootfs_size(blocks) + + label_str = "-n boot" + if self.label: + label_str = "-n %s" % self.label + + size_str = "" + if self.fstype == 'msdos': + size_str = "-F 16" # FAT 16 + + dosfs_cmd = "mkdosfs %s -S 512 %s -C %s %d" % (label_str, size_str, + rootfs, rootfs_size) + exec_native_cmd(dosfs_cmd, native_sysroot) + + mcopy_cmd = "mcopy -i %s -s %s/* ::/" % (rootfs, rootfs_dir) + exec_native_cmd(mcopy_cmd, native_sysroot) + + chmod_cmd = "chmod 644 %s" % rootfs + exec_cmd(chmod_cmd) + + prepare_rootfs_vfat = prepare_rootfs_msdos + + def prepare_rootfs_squashfs(self, rootfs, oe_builddir, rootfs_dir, + native_sysroot, pseudo): + """ + Prepare content for a squashfs rootfs partition. + """ + squashfs_cmd = "mksquashfs %s %s -noappend" % \ + (rootfs_dir, rootfs) + exec_native_cmd(squashfs_cmd, native_sysroot, pseudo=pseudo) + + def prepare_empty_partition_ext(self, rootfs, oe_builddir, + native_sysroot): + """ + Prepare an empty ext2/3/4 partition. + """ + size = self.disk_size + with open(rootfs, 'w') as sparse: + os.ftruncate(sparse.fileno(), size * 1024) + + extra_imagecmd = "-i 8192" + + label_str = "" + if self.label: + label_str = "-L %s" % self.label + + mkfs_cmd = "mkfs.%s -F %s %s %s" % \ + (self.fstype, extra_imagecmd, label_str, rootfs) + exec_native_cmd(mkfs_cmd, native_sysroot) + + def prepare_empty_partition_btrfs(self, rootfs, oe_builddir, + native_sysroot): + """ + Prepare an empty btrfs partition. + """ + size = self.disk_size + with open(rootfs, 'w') as sparse: + os.ftruncate(sparse.fileno(), size * 1024) + + label_str = "" + if self.label: + label_str = "-L %s" % self.label + + mkfs_cmd = "mkfs.%s -b %d %s %s" % \ + (self.fstype, self.size * 1024, label_str, rootfs) + exec_native_cmd(mkfs_cmd, native_sysroot) + + def prepare_empty_partition_msdos(self, rootfs, oe_builddir, + native_sysroot): + """ + Prepare an empty vfat partition. + """ + blocks = self.disk_size + + label_str = "-n boot" + if self.label: + label_str = "-n %s" % self.label + + size_str = "" + if self.fstype == 'msdos': + size_str = "-F 16" # FAT 16 + + dosfs_cmd = "mkdosfs %s -S 512 %s -C %s %d" % (label_str, size_str, + rootfs, blocks) + exec_native_cmd(dosfs_cmd, native_sysroot) + + chmod_cmd = "chmod 644 %s" % rootfs + exec_cmd(chmod_cmd) + + prepare_empty_partition_vfat = prepare_empty_partition_msdos + + def prepare_swap_partition(self, cr_workdir, oe_builddir, native_sysroot): + """ + Prepare a swap partition. + """ + path = "%s/fs.%s" % (cr_workdir, self.fstype) + + with open(path, 'w') as sparse: + os.ftruncate(sparse.fileno(), self.size * 1024) + + import uuid + label_str = "" + if self.label: + label_str = "-L %s" % self.label + mkswap_cmd = "mkswap %s -U %s %s" % (label_str, str(uuid.uuid1()), path) + exec_native_cmd(mkswap_cmd, native_sysroot) diff --git a/scripts/lib/wic/pluginbase.py b/scripts/lib/wic/pluginbase.py new file mode 100644 index 0000000000..fb3d179c2d --- /dev/null +++ b/scripts/lib/wic/pluginbase.py @@ -0,0 +1,140 @@ +#!/usr/bin/env python -tt +# +# Copyright (c) 2011 Intel, Inc. +# +# This program is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by the Free +# Software Foundation; version 2 of the License +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY +# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., 59 +# Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +__all__ = ['ImagerPlugin', 'SourcePlugin'] + +import os +import logging + +from collections import defaultdict +from importlib.machinery import SourceFileLoader + +from wic import WicError +from wic.utils.misc import get_bitbake_var + +PLUGIN_TYPES = ["imager", "source"] + +SCRIPTS_PLUGIN_DIR = "scripts/lib/wic/plugins" + +logger = logging.getLogger('wic') + +PLUGINS = defaultdict(dict) + +class PluginMgr: + _plugin_dirs = [] + + @classmethod + def get_plugins(cls, ptype): + """Get dictionary of <plugin_name>:<class> pairs.""" + if ptype not in PLUGIN_TYPES: + raise WicError('%s is not valid plugin type' % ptype) + + # collect plugin directories + if not cls._plugin_dirs: + cls._plugin_dirs = [os.path.join(os.path.dirname(__file__), 'plugins')] + layers = get_bitbake_var("BBLAYERS") or '' + for layer_path in layers.split(): + path = os.path.join(layer_path, SCRIPTS_PLUGIN_DIR) + path = os.path.abspath(os.path.expanduser(path)) + if path not in cls._plugin_dirs and os.path.isdir(path): + cls._plugin_dirs.insert(0, path) + + if ptype not in PLUGINS: + # load all ptype plugins + for pdir in cls._plugin_dirs: + ppath = os.path.join(pdir, ptype) + if os.path.isdir(ppath): + for fname in os.listdir(ppath): + if fname.endswith('.py'): + mname = fname[:-3] + mpath = os.path.join(ppath, fname) + logger.debug("loading plugin module %s", mpath) + SourceFileLoader(mname, mpath).load_module() + + return PLUGINS.get(ptype) + +class PluginMeta(type): + def __new__(cls, name, bases, attrs): + class_type = type.__new__(cls, name, bases, attrs) + if 'name' in attrs: + PLUGINS[class_type.wic_plugin_type][attrs['name']] = class_type + + return class_type + +class ImagerPlugin(metaclass=PluginMeta): + wic_plugin_type = "imager" + + def do_create(self): + raise WicError("Method %s.do_create is not implemented" % + self.__class__.__name__) + +class SourcePlugin(metaclass=PluginMeta): + wic_plugin_type = "source" + """ + The methods that can be implemented by --source plugins. + + Any methods not implemented in a subclass inherit these. + """ + + @classmethod + def do_install_disk(cls, disk, disk_name, creator, workdir, oe_builddir, + bootimg_dir, kernel_dir, native_sysroot): + """ + Called after all partitions have been prepared and assembled into a + disk image. This provides a hook to allow finalization of a + disk image e.g. to write an MBR to it. + """ + logger.debug("SourcePlugin: do_install_disk: disk: %s", disk_name) + + @classmethod + def do_stage_partition(cls, part, source_params, creator, cr_workdir, + oe_builddir, bootimg_dir, kernel_dir, + native_sysroot): + """ + Special content staging hook called before do_prepare_partition(), + normally empty. + + Typically, a partition will just use the passed-in parame e.g + straight bootimg_dir, etc, but in some cases, things need to + be more tailored e.g. to use a deploy dir + /boot, etc. This + hook allows those files to be staged in a customized fashion. + Not that get_bitbake_var() allows you to acces non-standard + variables that you might want to use for this. + """ + logger.debug("SourcePlugin: do_stage_partition: part: %s", part) + + @classmethod + def do_configure_partition(cls, part, source_params, creator, cr_workdir, + oe_builddir, bootimg_dir, kernel_dir, + native_sysroot): + """ + Called before do_prepare_partition(), typically used to create + custom configuration files for a partition, for example + syslinux or grub config files. + """ + logger.debug("SourcePlugin: do_configure_partition: part: %s", part) + + @classmethod + def do_prepare_partition(cls, part, source_params, creator, cr_workdir, + oe_builddir, bootimg_dir, kernel_dir, rootfs_dir, + native_sysroot): + """ + Called to do the actual content population for a partition i.e. it + 'prepares' the partition to be incorporated into the image. + """ + logger.debug("SourcePlugin: do_prepare_partition: part: %s", part) + diff --git a/scripts/lib/wic/plugins/imager/direct.py b/scripts/lib/wic/plugins/imager/direct.py new file mode 100644 index 0000000000..f2e6127331 --- /dev/null +++ b/scripts/lib/wic/plugins/imager/direct.py @@ -0,0 +1,561 @@ +# ex:ts=4:sw=4:sts=4:et +# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- +# +# Copyright (c) 2013, Intel Corporation. +# All rights reserved. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +# +# DESCRIPTION +# This implements the 'direct' imager plugin class for 'wic' +# +# AUTHORS +# Tom Zanussi <tom.zanussi (at] linux.intel.com> +# + +import logging +import os +import shutil +import tempfile +import uuid + +from time import strftime + +from wic import WicError +from wic.filemap import sparse_copy +from wic.ksparser import KickStart, KickStartError +from wic.pluginbase import PluginMgr, ImagerPlugin +from wic.utils.misc import get_bitbake_var, exec_cmd, exec_native_cmd + +logger = logging.getLogger('wic') + +class DirectPlugin(ImagerPlugin): + """ + Install a system into a file containing a partitioned disk image. + + An image file is formatted with a partition table, each partition + created from a rootfs or other OpenEmbedded build artifact and dd'ed + into the virtual disk. The disk image can subsequently be dd'ed onto + media and used on actual hardware. + """ + name = 'direct' + + def __init__(self, wks_file, rootfs_dir, bootimg_dir, kernel_dir, + native_sysroot, oe_builddir, options): + try: + self.ks = KickStart(wks_file) + except KickStartError as err: + raise WicError(str(err)) + + # parse possible 'rootfs=name' items + self.rootfs_dir = dict(rdir.split('=') for rdir in rootfs_dir.split(' ')) + self.bootimg_dir = bootimg_dir + self.kernel_dir = kernel_dir + self.native_sysroot = native_sysroot + self.oe_builddir = oe_builddir + + self.outdir = options.outdir + self.compressor = options.compressor + self.bmap = options.bmap + + self.name = "%s-%s" % (os.path.splitext(os.path.basename(wks_file))[0], + strftime("%Y%m%d%H%M")) + self.workdir = tempfile.mkdtemp(dir=self.outdir, prefix='tmp.wic.') + self._image = None + self.ptable_format = self.ks.bootloader.ptable + self.parts = self.ks.partitions + + # as a convenience, set source to the boot partition source + # instead of forcing it to be set via bootloader --source + for part in self.parts: + if not self.ks.bootloader.source and part.mountpoint == "/boot": + self.ks.bootloader.source = part.source + break + + image_path = self._full_path(self.workdir, self.parts[0].disk, "direct") + self._image = PartitionedImage(image_path, self.ptable_format, + self.parts, self.native_sysroot) + + def do_create(self): + """ + Plugin entry point. + """ + try: + self.create() + self.assemble() + self.finalize() + self.print_info() + finally: + self.cleanup() + + def _write_fstab(self, image_rootfs): + """overriden to generate fstab (temporarily) in rootfs. This is called + from _create, make sure it doesn't get called from + BaseImage.create() + """ + if not image_rootfs: + return + + fstab_path = image_rootfs + "/etc/fstab" + if not os.path.isfile(fstab_path): + return + + with open(fstab_path) as fstab: + fstab_lines = fstab.readlines() + + if self._update_fstab(fstab_lines, self.parts): + shutil.copyfile(fstab_path, fstab_path + ".orig") + + with open(fstab_path, "w") as fstab: + fstab.writelines(fstab_lines) + + return fstab_path + + def _update_fstab(self, fstab_lines, parts): + """Assume partition order same as in wks""" + updated = False + for part in parts: + if not part.realnum or not part.mountpoint \ + or part.mountpoint in ("/", "/boot"): + continue + + # mmc device partitions are named mmcblk0p1, mmcblk0p2.. + prefix = 'p' if part.disk.startswith('mmcblk') else '' + device_name = "/dev/%s%s%d" % (part.disk, prefix, part.realnum) + + opts = part.fsopts if part.fsopts else "defaults" + line = "\t".join([device_name, part.mountpoint, part.fstype, + opts, "0", "0"]) + "\n" + + fstab_lines.append(line) + updated = True + + return updated + + def _full_path(self, path, name, extention): + """ Construct full file path to a file we generate. """ + return os.path.join(path, "%s-%s.%s" % (self.name, name, extention)) + + # + # Actual implemention + # + def create(self): + """ + For 'wic', we already have our build artifacts - we just create + filesystems from the artifacts directly and combine them into + a partitioned image. + """ + fstab_path = self._write_fstab(self.rootfs_dir.get("ROOTFS_DIR")) + + for part in self.parts: + # get rootfs size from bitbake variable if it's not set in .ks file + if not part.size: + # and if rootfs name is specified for the partition + image_name = self.rootfs_dir.get(part.rootfs_dir) + if image_name and os.path.sep not in image_name: + # Bitbake variable ROOTFS_SIZE is calculated in + # Image._get_rootfs_size method from meta/lib/oe/image.py + # using IMAGE_ROOTFS_SIZE, IMAGE_ROOTFS_ALIGNMENT, + # IMAGE_OVERHEAD_FACTOR and IMAGE_ROOTFS_EXTRA_SPACE + rsize_bb = get_bitbake_var('ROOTFS_SIZE', image_name) + if rsize_bb: + part.size = int(round(float(rsize_bb))) + + self._image.prepare(self) + + if fstab_path: + shutil.move(fstab_path + ".orig", fstab_path) + + self._image.layout_partitions() + self._image.create() + + def assemble(self): + """ + Assemble partitions into disk image + """ + self._image.assemble() + + def finalize(self): + """ + Finalize the disk image. + + For example, prepare the image to be bootable by e.g. + creating and installing a bootloader configuration. + """ + source_plugin = self.ks.bootloader.source + disk_name = self.parts[0].disk + if source_plugin: + plugin = PluginMgr.get_plugins('source')[source_plugin] + plugin.do_install_disk(self._image, disk_name, self, self.workdir, + self.oe_builddir, self.bootimg_dir, + self.kernel_dir, self.native_sysroot) + + full_path = self._image.path + # Generate .bmap + if self.bmap: + logger.debug("Generating bmap file for %s", disk_name) + exec_native_cmd("bmaptool create %s -o %s.bmap" % (full_path, full_path), + self.native_sysroot) + # Compress the image + if self.compressor: + logger.debug("Compressing disk %s with %s", disk_name, self.compressor) + exec_cmd("%s %s" % (self.compressor, full_path)) + + def print_info(self): + """ + Print the image(s) and artifacts used, for the user. + """ + msg = "The new image(s) can be found here:\n" + + extension = "direct" + {"gzip": ".gz", + "bzip2": ".bz2", + "xz": ".xz", + None: ""}.get(self.compressor) + full_path = self._full_path(self.outdir, self.parts[0].disk, extension) + msg += ' %s\n\n' % full_path + + msg += 'The following build artifacts were used to create the image(s):\n' + for part in self.parts: + if part.rootfs_dir is None: + continue + if part.mountpoint == '/': + suffix = ':' + else: + suffix = '["%s"]:' % (part.mountpoint or part.label) + msg += ' ROOTFS_DIR%s%s\n' % (suffix.ljust(20), part.rootfs_dir) + + msg += ' BOOTIMG_DIR: %s\n' % self.bootimg_dir + msg += ' KERNEL_DIR: %s\n' % self.kernel_dir + msg += ' NATIVE_SYSROOT: %s\n' % self.native_sysroot + + logger.info(msg) + + @property + def rootdev(self): + """ + Get root device name to use as a 'root' parameter + in kernel command line. + + Assume partition order same as in wks + """ + for part in self.parts: + if part.mountpoint == "/": + if part.uuid: + return "PARTUUID=%s" % part.uuid + else: + suffix = 'p' if part.disk.startswith('mmcblk') else '' + return "/dev/%s%s%-d" % (part.disk, suffix, part.realnum) + + def cleanup(self): + if self._image: + self._image.cleanup() + + # Move results to the output dir + if not os.path.exists(self.outdir): + os.makedirs(self.outdir) + + for fname in os.listdir(self.workdir): + path = os.path.join(self.workdir, fname) + if os.path.isfile(path): + shutil.move(path, os.path.join(self.outdir, fname)) + + # remove work directory + shutil.rmtree(self.workdir, ignore_errors=True) + +# Overhead of the MBR partitioning scheme (just one sector) +MBR_OVERHEAD = 1 + +# Overhead of the GPT partitioning scheme +GPT_OVERHEAD = 34 + +# Size of a sector in bytes +SECTOR_SIZE = 512 + +class PartitionedImage(): + """ + Partitioned image in a file. + """ + + def __init__(self, path, ptable_format, partitions, native_sysroot=None): + self.path = path # Path to the image file + self.numpart = 0 # Number of allocated partitions + self.realpart = 0 # Number of partitions in the partition table + self.offset = 0 # Offset of next partition (in sectors) + self.min_size = 0 # Minimum required disk size to fit + # all partitions (in bytes) + self.ptable_format = ptable_format # Partition table format + # Disk system identifier + self.identifier = int.from_bytes(os.urandom(4), 'little') + + self.partitions = partitions + self.partimages = [] + # Size of a sector used in calculations + self.sector_size = SECTOR_SIZE + self.native_sysroot = native_sysroot + + # calculate the real partition number, accounting for partitions not + # in the partition table and logical partitions + realnum = 0 + for part in self.partitions: + if part.no_table: + part.realnum = 0 + else: + realnum += 1 + if self.ptable_format == 'msdos' and realnum > 3: + part.realnum = realnum + 1 + continue + part.realnum = realnum + + # generate parition UUIDs + for part in self.partitions: + if not part.uuid and part.use_uuid: + if self.ptable_format == 'gpt': + part.uuid = str(uuid.uuid4()) + else: # msdos partition table + part.uuid = '%08x-%02d' % (self.identifier, part.realnum) + + def prepare(self, imager): + """Prepare an image. Call prepare method of all image partitions.""" + for part in self.partitions: + # need to create the filesystems in order to get their + # sizes before we can add them and do the layout. + part.prepare(imager, imager.workdir, imager.oe_builddir, + imager.rootfs_dir, imager.bootimg_dir, + imager.kernel_dir, imager.native_sysroot) + + # Converting kB to sectors for parted + part.size_sec = part.disk_size * 1024 // self.sector_size + + def layout_partitions(self): + """ Layout the partitions, meaning calculate the position of every + partition on the disk. The 'ptable_format' parameter defines the + partition table format and may be "msdos". """ + + logger.debug("Assigning %s partitions to disks", self.ptable_format) + + # The number of primary and logical partitions. Extended partition and + # partitions not listed in the table are not included. + num_real_partitions = len([p for p in self.partitions if not p.no_table]) + + # Go through partitions in the order they are added in .ks file + for num in range(len(self.partitions)): + part = self.partitions[num] + + if self.ptable_format == 'msdos' and part.part_type: + # The --part-type can also be implemented for MBR partitions, + # in which case it would map to the 1-byte "partition type" + # filed at offset 3 of the partition entry. + raise WicError("setting custom partition type is not " \ + "implemented for msdos partitions") + + # Get the disk where the partition is located + self.numpart += 1 + if not part.no_table: + self.realpart += 1 + + if self.numpart == 1: + if self.ptable_format == "msdos": + overhead = MBR_OVERHEAD + elif self.ptable_format == "gpt": + overhead = GPT_OVERHEAD + + # Skip one sector required for the partitioning scheme overhead + self.offset += overhead + + if self.realpart > 3 and num_real_partitions > 4: + # Reserve a sector for EBR for every logical partition + # before alignment is performed. + if self.ptable_format == "msdos": + self.offset += 1 + + if part.align: + # If not first partition and we do have alignment set we need + # to align the partition. + # FIXME: This leaves a empty spaces to the disk. To fill the + # gaps we could enlargea the previous partition? + + # Calc how much the alignment is off. + align_sectors = self.offset % (part.align * 1024 // self.sector_size) + + if align_sectors: + # If partition is not aligned as required, we need + # to move forward to the next alignment point + align_sectors = (part.align * 1024 // self.sector_size) - align_sectors + + logger.debug("Realignment for %s%s with %s sectors, original" + " offset %s, target alignment is %sK.", + part.disk, self.numpart, align_sectors, + self.offset, part.align) + + # increase the offset so we actually start the partition on right alignment + self.offset += align_sectors + + part.start = self.offset + self.offset += part.size_sec + + part.type = 'primary' + if not part.no_table: + part.num = self.realpart + else: + part.num = 0 + + if self.ptable_format == "msdos": + # only count the partitions that are in partition table + if num_real_partitions > 4: + if self.realpart > 3: + part.type = 'logical' + part.num = self.realpart + 1 + + logger.debug("Assigned %s to %s%d, sectors range %d-%d size %d " + "sectors (%d bytes).", part.mountpoint, part.disk, + part.num, part.start, self.offset - 1, part.size_sec, + part.size_sec * self.sector_size) + + # Once all the partitions have been layed out, we can calculate the + # minumim disk size + self.min_size = self.offset + if self.ptable_format == "gpt": + self.min_size += GPT_OVERHEAD + + self.min_size *= self.sector_size + + def _create_partition(self, device, parttype, fstype, start, size): + """ Create a partition on an image described by the 'device' object. """ + + # Start is included to the size so we need to substract one from the end. + end = start + size - 1 + logger.debug("Added '%s' partition, sectors %d-%d, size %d sectors", + parttype, start, end, size) + + cmd = "parted -s %s unit s mkpart %s" % (device, parttype) + if fstype: + cmd += " %s" % fstype + cmd += " %d %d" % (start, end) + + return exec_native_cmd(cmd, self.native_sysroot) + + def create(self): + logger.debug("Creating sparse file %s", self.path) + with open(self.path, 'w') as sparse: + os.ftruncate(sparse.fileno(), self.min_size) + + logger.debug("Initializing partition table for %s", self.path) + exec_native_cmd("parted -s %s mklabel %s" % + (self.path, self.ptable_format), self.native_sysroot) + + logger.debug("Set disk identifier %x", self.identifier) + with open(self.path, 'r+b') as img: + img.seek(0x1B8) + img.write(self.identifier.to_bytes(4, 'little')) + + logger.debug("Creating partitions") + + for part in self.partitions: + if part.num == 0: + continue + + if self.ptable_format == "msdos" and part.num == 5: + # Create an extended partition (note: extended + # partition is described in MBR and contains all + # logical partitions). The logical partitions save a + # sector for an EBR just before the start of a + # partition. The extended partition must start one + # sector before the start of the first logical + # partition. This way the first EBR is inside of the + # extended partition. Since the extended partitions + # starts a sector before the first logical partition, + # add a sector at the back, so that there is enough + # room for all logical partitions. + self._create_partition(self.path, "extended", + None, part.start - 1, + self.offset - part.start + 1) + + if part.fstype == "swap": + parted_fs_type = "linux-swap" + elif part.fstype == "vfat": + parted_fs_type = "fat32" + elif part.fstype == "msdos": + parted_fs_type = "fat16" + if not part.system_id: + part.system_id = '0x6' # FAT16 + else: + # Type for ext2/ext3/ext4/btrfs + parted_fs_type = "ext2" + + # Boot ROM of OMAP boards require vfat boot partition to have an + # even number of sectors. + if part.mountpoint == "/boot" and part.fstype in ["vfat", "msdos"] \ + and part.size_sec % 2: + logger.debug("Subtracting one sector from '%s' partition to " + "get even number of sectors for the partition", + part.mountpoint) + part.size_sec -= 1 + + self._create_partition(self.path, part.type, + parted_fs_type, part.start, part.size_sec) + + if part.part_type: + logger.debug("partition %d: set type UID to %s", + part.num, part.part_type) + exec_native_cmd("sgdisk --typecode=%d:%s %s" % \ + (part.num, part.part_type, + self.path), self.native_sysroot) + + if part.uuid and self.ptable_format == "gpt": + logger.debug("partition %d: set UUID to %s", + part.num, part.uuid) + exec_native_cmd("sgdisk --partition-guid=%d:%s %s" % \ + (part.num, part.uuid, self.path), + self.native_sysroot) + + if part.label and self.ptable_format == "gpt": + logger.debug("partition %d: set name to %s", + part.num, part.label) + exec_native_cmd("parted -s %s name %d %s" % \ + (self.path, part.num, part.label), + self.native_sysroot) + + if part.active: + flag_name = "legacy_boot" if self.ptable_format == 'gpt' else "boot" + logger.debug("Set '%s' flag for partition '%s' on disk '%s'", + flag_name, part.num, self.path) + exec_native_cmd("parted -s %s set %d %s on" % \ + (self.path, part.num, flag_name), + self.native_sysroot) + if part.system_id: + exec_native_cmd("sfdisk --part-type %s %s %s" % \ + (self.path, part.num, part.system_id), + self.native_sysroot) + + def cleanup(self): + # remove partition images + for image in set(self.partimages): + os.remove(image) + + def assemble(self): + logger.debug("Installing partitions") + + for part in self.partitions: + source = part.source_file + if source: + # install source_file contents into a partition + sparse_copy(source, self.path, part.start * self.sector_size) + + logger.debug("Installed %s in partition %d, sectors %d-%d, " + "size %d sectors", source, part.num, part.start, + part.start + part.size_sec - 1, part.size_sec) + + partimage = self.path + '.p%d' % part.num + os.rename(source, partimage) + self.partimages.append(partimage) diff --git a/scripts/lib/wic/plugins/source/bootimg-efi.py b/scripts/lib/wic/plugins/source/bootimg-efi.py new file mode 100644 index 0000000000..9879cb9fce --- /dev/null +++ b/scripts/lib/wic/plugins/source/bootimg-efi.py @@ -0,0 +1,257 @@ +# ex:ts=4:sw=4:sts=4:et +# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- +# +# Copyright (c) 2014, Intel Corporation. +# All rights reserved. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +# +# DESCRIPTION +# This implements the 'bootimg-efi' source plugin class for 'wic' +# +# AUTHORS +# Tom Zanussi <tom.zanussi (at] linux.intel.com> +# + +import logging +import os +import shutil + +from wic import WicError +from wic.engine import get_custom_config +from wic.pluginbase import SourcePlugin +from wic.utils.misc import (exec_cmd, exec_native_cmd, get_bitbake_var, + BOOTDD_EXTRA_SPACE) + +logger = logging.getLogger('wic') + +class BootimgEFIPlugin(SourcePlugin): + """ + Create EFI boot partition. + This plugin supports GRUB 2 and systemd-boot bootloaders. + """ + + name = 'bootimg-efi' + + @classmethod + def do_configure_grubefi(cls, creator, cr_workdir): + """ + Create loader-specific (grub-efi) config + """ + configfile = creator.ks.bootloader.configfile + custom_cfg = None + if configfile: + custom_cfg = get_custom_config(configfile) + if custom_cfg: + # Use a custom configuration for grub + grubefi_conf = custom_cfg + logger.debug("Using custom configuration file " + "%s for grub.cfg", configfile) + else: + raise WicError("configfile is specified but failed to " + "get it from %s." % configfile) + + if not custom_cfg: + # Create grub configuration using parameters from wks file + bootloader = creator.ks.bootloader + + grubefi_conf = "" + grubefi_conf += "serial --unit=0 --speed=115200 --word=8 --parity=no --stop=1\n" + grubefi_conf += "default=boot\n" + grubefi_conf += "timeout=%s\n" % bootloader.timeout + grubefi_conf += "menuentry 'boot'{\n" + + kernel = "/bzImage" + + grubefi_conf += "linux %s root=%s rootwait %s\n" \ + % (kernel, creator.rootdev, bootloader.append) + grubefi_conf += "}\n" + + logger.debug("Writing grubefi config %s/hdd/boot/EFI/BOOT/grub.cfg", + cr_workdir) + cfg = open("%s/hdd/boot/EFI/BOOT/grub.cfg" % cr_workdir, "w") + cfg.write(grubefi_conf) + cfg.close() + + @classmethod + def do_configure_systemdboot(cls, hdddir, creator, cr_workdir, source_params): + """ + Create loader-specific systemd-boot/gummiboot config + """ + install_cmd = "install -d %s/loader" % hdddir + exec_cmd(install_cmd) + + install_cmd = "install -d %s/loader/entries" % hdddir + exec_cmd(install_cmd) + + bootloader = creator.ks.bootloader + + loader_conf = "" + loader_conf += "default boot\n" + loader_conf += "timeout %d\n" % bootloader.timeout + + initrd = source_params.get('initrd') + + if initrd: + # obviously we need to have a common common deploy var + bootimg_dir = get_bitbake_var("DEPLOY_DIR_IMAGE") + if not bootimg_dir: + raise WicError("Couldn't find DEPLOY_DIR_IMAGE, exiting") + + cp_cmd = "cp %s/%s %s" % (bootimg_dir, initrd, hdddir) + exec_cmd(cp_cmd, True) + else: + logger.debug("Ignoring missing initrd") + + logger.debug("Writing systemd-boot config " + "%s/hdd/boot/loader/loader.conf", cr_workdir) + cfg = open("%s/hdd/boot/loader/loader.conf" % cr_workdir, "w") + cfg.write(loader_conf) + cfg.close() + + configfile = creator.ks.bootloader.configfile + custom_cfg = None + if configfile: + custom_cfg = get_custom_config(configfile) + if custom_cfg: + # Use a custom configuration for systemd-boot + boot_conf = custom_cfg + logger.debug("Using custom configuration file " + "%s for systemd-boots's boot.conf", configfile) + else: + raise WicError("configfile is specified but failed to " + "get it from %s.", configfile) + + if not custom_cfg: + # Create systemd-boot configuration using parameters from wks file + kernel = "/bzImage" + + boot_conf = "" + boot_conf += "title boot\n" + boot_conf += "linux %s\n" % kernel + boot_conf += "options LABEL=Boot root=%s %s\n" % \ + (creator.rootdev, bootloader.append) + + if initrd: + boot_conf += "initrd /%s\n" % initrd + + logger.debug("Writing systemd-boot config " + "%s/hdd/boot/loader/entries/boot.conf", cr_workdir) + cfg = open("%s/hdd/boot/loader/entries/boot.conf" % cr_workdir, "w") + cfg.write(boot_conf) + cfg.close() + + + @classmethod + def do_configure_partition(cls, part, source_params, creator, cr_workdir, + oe_builddir, bootimg_dir, kernel_dir, + native_sysroot): + """ + Called before do_prepare_partition(), creates loader-specific config + """ + hdddir = "%s/hdd/boot" % cr_workdir + + install_cmd = "install -d %s/EFI/BOOT" % hdddir + exec_cmd(install_cmd) + + try: + if source_params['loader'] == 'grub-efi': + cls.do_configure_grubefi(creator, cr_workdir) + elif source_params['loader'] == 'systemd-boot': + cls.do_configure_systemdboot(hdddir, creator, cr_workdir, source_params) + else: + raise WicError("unrecognized bootimg-efi loader: %s" % source_params['loader']) + except KeyError: + raise WicError("bootimg-efi requires a loader, none specified") + + + @classmethod + def do_prepare_partition(cls, part, source_params, creator, cr_workdir, + oe_builddir, bootimg_dir, kernel_dir, + rootfs_dir, native_sysroot): + """ + Called to do the actual content population for a partition i.e. it + 'prepares' the partition to be incorporated into the image. + In this case, prepare content for an EFI (grub) boot partition. + """ + if not kernel_dir: + kernel_dir = get_bitbake_var("DEPLOY_DIR_IMAGE") + if not kernel_dir: + raise WicError("Couldn't find DEPLOY_DIR_IMAGE, exiting") + + staging_kernel_dir = kernel_dir + + hdddir = "%s/hdd/boot" % cr_workdir + + install_cmd = "install -m 0644 %s/bzImage %s/bzImage" % \ + (staging_kernel_dir, hdddir) + exec_cmd(install_cmd) + + + try: + if source_params['loader'] == 'grub-efi': + shutil.copyfile("%s/hdd/boot/EFI/BOOT/grub.cfg" % cr_workdir, + "%s/grub.cfg" % cr_workdir) + for mod in [x for x in os.listdir(kernel_dir) if x.startswith("grub-efi-")]: + cp_cmd = "cp %s/%s %s/EFI/BOOT/%s" % (kernel_dir, mod, hdddir, mod[9:]) + exec_cmd(cp_cmd, True) + shutil.move("%s/grub.cfg" % cr_workdir, + "%s/hdd/boot/EFI/BOOT/grub.cfg" % cr_workdir) + elif source_params['loader'] == 'systemd-boot': + for mod in [x for x in os.listdir(kernel_dir) if x.startswith("systemd-")]: + cp_cmd = "cp %s/%s %s/EFI/BOOT/%s" % (kernel_dir, mod, hdddir, mod[8:]) + exec_cmd(cp_cmd, True) + else: + raise WicError("unrecognized bootimg-efi loader: %s" % + source_params['loader']) + except KeyError: + raise WicError("bootimg-efi requires a loader, none specified") + + startup = os.path.join(kernel_dir, "startup.nsh") + if os.path.exists(startup): + cp_cmd = "cp %s %s/" % (startup, hdddir) + exec_cmd(cp_cmd, True) + + du_cmd = "du -bks %s" % hdddir + out = exec_cmd(du_cmd) + blocks = int(out.split()[0]) + + extra_blocks = part.get_extra_block_count(blocks) + + if extra_blocks < BOOTDD_EXTRA_SPACE: + extra_blocks = BOOTDD_EXTRA_SPACE + + blocks += extra_blocks + + logger.debug("Added %d extra blocks to %s to get to %d total blocks", + extra_blocks, part.mountpoint, blocks) + + # dosfs image, created by mkdosfs + bootimg = "%s/boot.img" % cr_workdir + + dosfs_cmd = "mkdosfs -n efi -C %s %d" % (bootimg, blocks) + exec_native_cmd(dosfs_cmd, native_sysroot) + + mcopy_cmd = "mcopy -i %s -s %s/* ::/" % (bootimg, hdddir) + exec_native_cmd(mcopy_cmd, native_sysroot) + + chmod_cmd = "chmod 644 %s" % bootimg + exec_cmd(chmod_cmd) + + du_cmd = "du -Lbks %s" % bootimg + out = exec_cmd(du_cmd) + bootimg_size = out.split()[0] + + part.size = int(bootimg_size) + part.source_file = bootimg diff --git a/scripts/lib/wic/plugins/source/bootimg-partition.py b/scripts/lib/wic/plugins/source/bootimg-partition.py new file mode 100644 index 0000000000..13fddbd478 --- /dev/null +++ b/scripts/lib/wic/plugins/source/bootimg-partition.py @@ -0,0 +1,123 @@ +# ex:ts=4:sw=4:sts=4:et +# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +# +# DESCRIPTION +# This implements the 'bootimg-partition' source plugin class for +# 'wic'. The plugin creates an image of boot partition, copying over +# files listed in IMAGE_BOOT_FILES bitbake variable. +# +# AUTHORS +# Maciej Borzecki <maciej.borzecki (at] open-rnd.pl> +# + +import logging +import os +import re + +from glob import glob + +from wic import WicError +from wic.pluginbase import SourcePlugin +from wic.utils.misc import exec_cmd, get_bitbake_var + +logger = logging.getLogger('wic') + +class BootimgPartitionPlugin(SourcePlugin): + """ + Create an image of boot partition, copying over files + listed in IMAGE_BOOT_FILES bitbake variable. + """ + + name = 'bootimg-partition' + + @classmethod + def do_prepare_partition(cls, part, source_params, cr, cr_workdir, + oe_builddir, bootimg_dir, kernel_dir, + rootfs_dir, native_sysroot): + """ + Called to do the actual content population for a partition i.e. it + 'prepares' the partition to be incorporated into the image. + In this case, does the following: + - sets up a vfat partition + - copies all files listed in IMAGE_BOOT_FILES variable + """ + hdddir = "%s/boot" % cr_workdir + install_cmd = "install -d %s" % hdddir + exec_cmd(install_cmd) + + if not kernel_dir: + kernel_dir = get_bitbake_var("DEPLOY_DIR_IMAGE") + if not kernel_dir: + raise WicError("Couldn't find DEPLOY_DIR_IMAGE, exiting") + + logger.debug('Kernel dir: %s', bootimg_dir) + + boot_files = get_bitbake_var("IMAGE_BOOT_FILES") + + if not boot_files: + raise WicError('No boot files defined, IMAGE_BOOT_FILES unset') + + logger.debug('Boot files: %s', boot_files) + + # list of tuples (src_name, dst_name) + deploy_files = [] + for src_entry in re.findall(r'[\w;\-\./\*]+', boot_files): + if ';' in src_entry: + dst_entry = tuple(src_entry.split(';')) + if not dst_entry[0] or not dst_entry[1]: + raise WicError('Malformed boot file entry: %s' % src_entry) + else: + dst_entry = (src_entry, src_entry) + + logger.debug('Destination entry: %r', dst_entry) + deploy_files.append(dst_entry) + + for deploy_entry in deploy_files: + src, dst = deploy_entry + install_task = [] + if '*' in src: + # by default install files under their basename + entry_name_fn = os.path.basename + if dst != src: + # unless a target name was given, then treat name + # as a directory and append a basename + entry_name_fn = lambda name: \ + os.path.join(dst, + os.path.basename(name)) + + srcs = glob(os.path.join(kernel_dir, src)) + + logger.debug('Globbed sources: %s', ', '.join(srcs)) + for entry in srcs: + entry_dst_name = entry_name_fn(entry) + install_task.append((entry, + os.path.join(hdddir, + entry_dst_name))) + else: + install_task = [(os.path.join(kernel_dir, src), + os.path.join(hdddir, dst))] + + for task in install_task: + src_path, dst_path = task + logger.debug('Install %s as %s', + os.path.basename(src_path), dst_path) + install_cmd = "install -m 0644 -D %s %s" \ + % (src_path, dst_path) + exec_cmd(install_cmd) + + logger.debug('Prepare boot partition using rootfs in %s', hdddir) + part.prepare_rootfs(cr_workdir, oe_builddir, hdddir, + native_sysroot) diff --git a/scripts/lib/wic/plugins/source/bootimg-pcbios.py b/scripts/lib/wic/plugins/source/bootimg-pcbios.py new file mode 100644 index 0000000000..5890c1267b --- /dev/null +++ b/scripts/lib/wic/plugins/source/bootimg-pcbios.py @@ -0,0 +1,208 @@ +# ex:ts=4:sw=4:sts=4:et +# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- +# +# Copyright (c) 2014, Intel Corporation. +# All rights reserved. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +# +# DESCRIPTION +# This implements the 'bootimg-pcbios' source plugin class for 'wic' +# +# AUTHORS +# Tom Zanussi <tom.zanussi (at] linux.intel.com> +# + +import logging +import os + +from wic import WicError +from wic.engine import get_custom_config +from wic.utils import runner +from wic.pluginbase import SourcePlugin +from wic.utils.misc import (exec_cmd, exec_native_cmd, + get_bitbake_var, BOOTDD_EXTRA_SPACE) + +logger = logging.getLogger('wic') + +class BootimgPcbiosPlugin(SourcePlugin): + """ + Create MBR boot partition and install syslinux on it. + """ + + name = 'bootimg-pcbios' + + @classmethod + def _get_bootimg_dir(cls, bootimg_dir, dirname): + """ + Check if dirname exists in default bootimg_dir or + in wic-tools STAGING_DIR. + """ + for result in (bootimg_dir, get_bitbake_var("STAGING_DATADIR", "wic-tools")): + if os.path.exists("%s/%s" % (result, dirname)): + return result + + raise WicError("Couldn't find correct bootimg_dir, exiting") + + @classmethod + def do_install_disk(cls, disk, disk_name, creator, workdir, oe_builddir, + bootimg_dir, kernel_dir, native_sysroot): + """ + Called after all partitions have been prepared and assembled into a + disk image. In this case, we install the MBR. + """ + bootimg_dir = cls._get_bootimg_dir(bootimg_dir, 'syslinux') + mbrfile = "%s/syslinux/" % bootimg_dir + if creator.ptable_format == 'msdos': + mbrfile += "mbr.bin" + elif creator.ptable_format == 'gpt': + mbrfile += "gptmbr.bin" + else: + raise WicError("Unsupported partition table: %s" % + creator.ptable_format) + + if not os.path.exists(mbrfile): + raise WicError("Couldn't find %s. If using the -e option, do you " + "have the right MACHINE set in local.conf? If not, " + "is the bootimg_dir path correct?" % mbrfile) + + full_path = creator._full_path(workdir, disk_name, "direct") + logger.debug("Installing MBR on disk %s as %s with size %s bytes", + disk_name, full_path, disk.min_size) + + dd_cmd = "dd if=%s of=%s conv=notrunc" % (mbrfile, full_path) + exec_cmd(dd_cmd, native_sysroot) + + @classmethod + def do_configure_partition(cls, part, source_params, creator, cr_workdir, + oe_builddir, bootimg_dir, kernel_dir, + native_sysroot): + """ + Called before do_prepare_partition(), creates syslinux config + """ + hdddir = "%s/hdd/boot" % cr_workdir + + install_cmd = "install -d %s" % hdddir + exec_cmd(install_cmd) + + bootloader = creator.ks.bootloader + + custom_cfg = None + if bootloader.configfile: + custom_cfg = get_custom_config(bootloader.configfile) + if custom_cfg: + # Use a custom configuration for grub + syslinux_conf = custom_cfg + logger.debug("Using custom configuration file %s " + "for syslinux.cfg", bootloader.configfile) + else: + raise WicError("configfile is specified but failed to " + "get it from %s." % bootloader.configfile) + + if not custom_cfg: + # Create syslinux configuration using parameters from wks file + splash = os.path.join(cr_workdir, "/hdd/boot/splash.jpg") + if os.path.exists(splash): + splashline = "menu background splash.jpg" + else: + splashline = "" + + syslinux_conf = "" + syslinux_conf += "PROMPT 0\n" + syslinux_conf += "TIMEOUT " + str(bootloader.timeout) + "\n" + syslinux_conf += "\n" + syslinux_conf += "ALLOWOPTIONS 1\n" + syslinux_conf += "SERIAL 0 115200\n" + syslinux_conf += "\n" + if splashline: + syslinux_conf += "%s\n" % splashline + syslinux_conf += "DEFAULT boot\n" + syslinux_conf += "LABEL boot\n" + + kernel = "/vmlinuz" + syslinux_conf += "KERNEL " + kernel + "\n" + + syslinux_conf += "APPEND label=boot root=%s %s\n" % \ + (creator.rootdev, bootloader.append) + + logger.debug("Writing syslinux config %s/hdd/boot/syslinux.cfg", + cr_workdir) + cfg = open("%s/hdd/boot/syslinux.cfg" % cr_workdir, "w") + cfg.write(syslinux_conf) + cfg.close() + + @classmethod + def do_prepare_partition(cls, part, source_params, creator, cr_workdir, + oe_builddir, bootimg_dir, kernel_dir, + rootfs_dir, native_sysroot): + """ + Called to do the actual content population for a partition i.e. it + 'prepares' the partition to be incorporated into the image. + In this case, prepare content for legacy bios boot partition. + """ + bootimg_dir = cls._get_bootimg_dir(bootimg_dir, 'syslinux') + + staging_kernel_dir = kernel_dir + + hdddir = "%s/hdd/boot" % cr_workdir + + cmds = ("install -m 0644 %s/bzImage %s/vmlinuz" % + (staging_kernel_dir, hdddir), + "install -m 444 %s/syslinux/ldlinux.sys %s/ldlinux.sys" % + (bootimg_dir, hdddir), + "install -m 0644 %s/syslinux/vesamenu.c32 %s/vesamenu.c32" % + (bootimg_dir, hdddir), + "install -m 444 %s/syslinux/libcom32.c32 %s/libcom32.c32" % + (bootimg_dir, hdddir), + "install -m 444 %s/syslinux/libutil.c32 %s/libutil.c32" % + (bootimg_dir, hdddir)) + + for install_cmd in cmds: + exec_cmd(install_cmd) + + du_cmd = "du -bks %s" % hdddir + out = exec_cmd(du_cmd) + blocks = int(out.split()[0]) + + extra_blocks = part.get_extra_block_count(blocks) + + if extra_blocks < BOOTDD_EXTRA_SPACE: + extra_blocks = BOOTDD_EXTRA_SPACE + + blocks += extra_blocks + + logger.debug("Added %d extra blocks to %s to get to %d total blocks", + extra_blocks, part.mountpoint, blocks) + + # dosfs image, created by mkdosfs + bootimg = "%s/boot.img" % cr_workdir + + dosfs_cmd = "mkdosfs -n boot -S 512 -C %s %d" % (bootimg, blocks) + exec_native_cmd(dosfs_cmd, native_sysroot) + + mcopy_cmd = "mcopy -i %s -s %s/* ::/" % (bootimg, hdddir) + exec_native_cmd(mcopy_cmd, native_sysroot) + + syslinux_cmd = "syslinux %s" % bootimg + exec_native_cmd(syslinux_cmd, native_sysroot) + + chmod_cmd = "chmod 644 %s" % bootimg + exec_cmd(chmod_cmd) + + du_cmd = "du -Lbks %s" % bootimg + out = exec_cmd(du_cmd) + bootimg_size = out.split()[0] + + part.size = int(bootimg_size) + part.source_file = bootimg diff --git a/scripts/lib/wic/plugins/source/isoimage-isohybrid.py b/scripts/lib/wic/plugins/source/isoimage-isohybrid.py new file mode 100644 index 0000000000..1ceba62be0 --- /dev/null +++ b/scripts/lib/wic/plugins/source/isoimage-isohybrid.py @@ -0,0 +1,494 @@ +# ex:ts=4:sw=4:sts=4:et +# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +# +# DESCRIPTION +# This implements the 'isoimage-isohybrid' source plugin class for 'wic' +# +# AUTHORS +# Mihaly Varga <mihaly.varga (at] ni.com> + +import glob +import logging +import os +import re +import shutil + +from wic import WicError +from wic.engine import get_custom_config +from wic.pluginbase import SourcePlugin +from wic.utils.misc import exec_cmd, exec_native_cmd, get_bitbake_var + +logger = logging.getLogger('wic') + +class IsoImagePlugin(SourcePlugin): + """ + Create a bootable ISO image + + This plugin creates a hybrid, legacy and EFI bootable ISO image. The + generated image can be used on optical media as well as USB media. + + Legacy boot uses syslinux and EFI boot uses grub or gummiboot (not + implemented yet) as bootloader. The plugin creates the directories required + by bootloaders and populates them by creating and configuring the + bootloader files. + + Example kickstart file: + part /boot --source isoimage-isohybrid --sourceparams="loader=grub-efi, \\ + image_name= IsoImage" --ondisk cd --label LIVECD --fstype=ext2 + bootloader --timeout=10 --append=" " + + In --sourceparams "loader" specifies the bootloader used for booting in EFI + mode, while "image_name" specifies the name of the generated image. In the + example above, wic creates an ISO image named IsoImage-cd.direct (default + extension added by direct imeger plugin) and a file named IsoImage-cd.iso + """ + + name = 'isoimage-isohybrid' + + @classmethod + def do_configure_syslinux(cls, creator, cr_workdir): + """ + Create loader-specific (syslinux) config + """ + splash = os.path.join(cr_workdir, "ISO/boot/splash.jpg") + if os.path.exists(splash): + splashline = "menu background splash.jpg" + else: + splashline = "" + + bootloader = creator.ks.bootloader + + syslinux_conf = "" + syslinux_conf += "PROMPT 0\n" + syslinux_conf += "TIMEOUT %s \n" % (bootloader.timeout or 10) + syslinux_conf += "\n" + syslinux_conf += "ALLOWOPTIONS 1\n" + syslinux_conf += "SERIAL 0 115200\n" + syslinux_conf += "\n" + if splashline: + syslinux_conf += "%s\n" % splashline + syslinux_conf += "DEFAULT boot\n" + syslinux_conf += "LABEL boot\n" + + kernel = "/bzImage" + syslinux_conf += "KERNEL " + kernel + "\n" + syslinux_conf += "APPEND initrd=/initrd LABEL=boot %s\n" \ + % bootloader.append + + logger.debug("Writing syslinux config %s/ISO/isolinux/isolinux.cfg", + cr_workdir) + + with open("%s/ISO/isolinux/isolinux.cfg" % cr_workdir, "w") as cfg: + cfg.write(syslinux_conf) + + @classmethod + def do_configure_grubefi(cls, part, creator, cr_workdir): + """ + Create loader-specific (grub-efi) config + """ + configfile = creator.ks.bootloader.configfile + if configfile: + grubefi_conf = get_custom_config(configfile) + if grubefi_conf: + logger.debug("Using custom configuration file %s for grub.cfg", + configfile) + else: + raise WicError("configfile is specified " + "but failed to get it from %s", configfile) + else: + splash = os.path.join(cr_workdir, "EFI/boot/splash.jpg") + if os.path.exists(splash): + splashline = "menu background splash.jpg" + else: + splashline = "" + + bootloader = creator.ks.bootloader + + grubefi_conf = "" + grubefi_conf += "serial --unit=0 --speed=115200 --word=8 " + grubefi_conf += "--parity=no --stop=1\n" + grubefi_conf += "default=boot\n" + grubefi_conf += "timeout=%s\n" % (bootloader.timeout or 10) + grubefi_conf += "\n" + grubefi_conf += "search --set=root --label %s " % part.label + grubefi_conf += "\n" + grubefi_conf += "menuentry 'boot'{\n" + + kernel = "/bzImage" + + grubefi_conf += "linux %s rootwait %s\n" \ + % (kernel, bootloader.append) + grubefi_conf += "initrd /initrd \n" + grubefi_conf += "}\n" + + if splashline: + grubefi_conf += "%s\n" % splashline + + logger.debug("Writing grubefi config %s/EFI/BOOT/grub.cfg", cr_workdir) + + with open("%s/EFI/BOOT/grub.cfg" % cr_workdir, "w") as cfg: + cfg.write(grubefi_conf) + + @staticmethod + def _build_initramfs_path(rootfs_dir, cr_workdir): + """ + Create path for initramfs image + """ + + initrd = get_bitbake_var("INITRD_LIVE") or get_bitbake_var("INITRD") + if not initrd: + initrd_dir = get_bitbake_var("DEPLOY_DIR_IMAGE") + if not initrd_dir: + raise WicError("Couldn't find DEPLOY_DIR_IMAGE, exiting.") + + image_name = get_bitbake_var("IMAGE_BASENAME") + if not image_name: + raise WicError("Couldn't find IMAGE_BASENAME, exiting.") + + image_type = get_bitbake_var("INITRAMFS_FSTYPES") + if not image_type: + raise WicError("Couldn't find INITRAMFS_FSTYPES, exiting.") + + target_arch = get_bitbake_var("TRANSLATED_TARGET_ARCH") + if not target_arch: + raise WicError("Couldn't find TRANSLATED_TARGET_ARCH, exiting.") + + initrd = glob.glob('%s/%s*%s.%s' % (initrd_dir, image_name, target_arch, image_type))[0] + + if not os.path.exists(initrd): + # Create initrd from rootfs directory + initrd = "%s/initrd.cpio.gz" % cr_workdir + initrd_dir = "%s/INITRD" % cr_workdir + shutil.copytree("%s" % rootfs_dir, \ + "%s" % initrd_dir, symlinks=True) + + if os.path.isfile("%s/init" % rootfs_dir): + shutil.copy2("%s/init" % rootfs_dir, "%s/init" % initrd_dir) + elif os.path.lexists("%s/init" % rootfs_dir): + os.symlink(os.readlink("%s/init" % rootfs_dir), \ + "%s/init" % initrd_dir) + elif os.path.isfile("%s/sbin/init" % rootfs_dir): + shutil.copy2("%s/sbin/init" % rootfs_dir, \ + "%s" % initrd_dir) + elif os.path.lexists("%s/sbin/init" % rootfs_dir): + os.symlink(os.readlink("%s/sbin/init" % rootfs_dir), \ + "%s/init" % initrd_dir) + else: + raise WicError("Couldn't find or build initrd, exiting.") + + exec_cmd("cd %s && find . | cpio -o -H newc -R +0:+0 >./initrd.cpio " \ + % initrd_dir, as_shell=True) + exec_cmd("gzip -f -9 -c %s/initrd.cpio > %s" \ + % (cr_workdir, initrd), as_shell=True) + shutil.rmtree(initrd_dir) + + return initrd + + @classmethod + def do_configure_partition(cls, part, source_params, creator, cr_workdir, + oe_builddir, bootimg_dir, kernel_dir, + native_sysroot): + """ + Called before do_prepare_partition(), creates loader-specific config + """ + isodir = "%s/ISO/" % cr_workdir + + if os.path.exists(cr_workdir): + shutil.rmtree(cr_workdir) + + install_cmd = "install -d %s " % isodir + exec_cmd(install_cmd) + + # Overwrite the name of the created image + logger.debug(source_params) + if 'image_name' in source_params and \ + source_params['image_name'].strip(): + creator.name = source_params['image_name'].strip() + logger.debug("The name of the image is: %s", creator.name) + + @classmethod + def do_prepare_partition(cls, part, source_params, creator, cr_workdir, + oe_builddir, bootimg_dir, kernel_dir, + rootfs_dir, native_sysroot): + """ + Called to do the actual content population for a partition i.e. it + 'prepares' the partition to be incorporated into the image. + In this case, prepare content for a bootable ISO image. + """ + + isodir = "%s/ISO" % cr_workdir + + if part.rootfs_dir is None: + if not 'ROOTFS_DIR' in rootfs_dir: + raise WicError("Couldn't find --rootfs-dir, exiting.") + rootfs_dir = rootfs_dir['ROOTFS_DIR'] + else: + if part.rootfs_dir in rootfs_dir: + rootfs_dir = rootfs_dir[part.rootfs_dir] + elif part.rootfs_dir: + rootfs_dir = part.rootfs_dir + else: + raise WicError("Couldn't find --rootfs-dir=%s connection " + "or it is not a valid path, exiting." % + part.rootfs_dir) + + if not os.path.isdir(rootfs_dir): + rootfs_dir = get_bitbake_var("IMAGE_ROOTFS") + if not os.path.isdir(rootfs_dir): + raise WicError("Couldn't find IMAGE_ROOTFS, exiting.") + + part.rootfs_dir = rootfs_dir + + # Prepare rootfs.img + deploy_dir = get_bitbake_var("DEPLOY_DIR_IMAGE") + img_iso_dir = get_bitbake_var("ISODIR") + rootfs_img = "%s/rootfs.img" % img_iso_dir + if not os.path.isfile(rootfs_img): + # check if rootfs.img is in deploydir + deploy_dir = get_bitbake_var("DEPLOY_DIR_IMAGE") + image_name = get_bitbake_var("IMAGE_LINK_NAME") + rootfs_img = "%s/%s.%s" \ + % (deploy_dir, image_name, part.fstype) + + if not os.path.isfile(rootfs_img): + # create image file with type specified by --fstype + # which contains rootfs + du_cmd = "du -bks %s" % rootfs_dir + out = exec_cmd(du_cmd) + part.size = int(out.split()[0]) + part.extra_space = 0 + part.overhead_factor = 1.2 + part.prepare_rootfs(cr_workdir, oe_builddir, rootfs_dir, \ + native_sysroot) + rootfs_img = part.source_file + + install_cmd = "install -m 0644 %s %s/rootfs.img" \ + % (rootfs_img, isodir) + exec_cmd(install_cmd) + + # Remove the temporary file created by part.prepare_rootfs() + if os.path.isfile(part.source_file): + os.remove(part.source_file) + + # Support using a different initrd other than default + if source_params.get('initrd'): + initrd = source_params['initrd'] + if not deploy_dir: + raise WicError("Couldn't find DEPLOY_DIR_IMAGE, exiting") + cp_cmd = "cp %s/%s %s" % (deploy_dir, initrd, cr_workdir) + exec_cmd(cp_cmd) + else: + # Prepare initial ramdisk + initrd = "%s/initrd" % deploy_dir + if not os.path.isfile(initrd): + initrd = "%s/initrd" % img_iso_dir + if not os.path.isfile(initrd): + initrd = cls._build_initramfs_path(rootfs_dir, cr_workdir) + + install_cmd = "install -m 0644 %s %s/initrd" % (initrd, isodir) + exec_cmd(install_cmd) + + # Remove the temporary file created by _build_initramfs_path function + if os.path.isfile("%s/initrd.cpio.gz" % cr_workdir): + os.remove("%s/initrd.cpio.gz" % cr_workdir) + + # Install bzImage + install_cmd = "install -m 0644 %s/bzImage %s/bzImage" % \ + (kernel_dir, isodir) + exec_cmd(install_cmd) + + #Create bootloader for efi boot + try: + if source_params['loader'] == 'grub-efi': + # Builds grub.cfg if ISODIR didn't exist or + # didn't contains grub.cfg + bootimg_dir = img_iso_dir + if not os.path.exists("%s/EFI/BOOT" % bootimg_dir): + bootimg_dir = "%s/bootimg" % cr_workdir + if os.path.exists(bootimg_dir): + shutil.rmtree(bootimg_dir) + install_cmd = "install -d %s/EFI/BOOT" % bootimg_dir + exec_cmd(install_cmd) + + if not os.path.isfile("%s/EFI/BOOT/boot.cfg" % bootimg_dir): + cls.do_configure_grubefi(part, creator, bootimg_dir) + + # Builds bootx64.efi/bootia32.efi if ISODIR didn't exist or + # didn't contains it + target_arch = get_bitbake_var("TARGET_SYS") + if not target_arch: + raise WicError("Coludn't find target architecture") + + if re.match("x86_64", target_arch): + grub_target = 'x86_64-efi' + grub_image = "bootx64.efi" + elif re.match('i.86', target_arch): + grub_target = 'i386-efi' + grub_image = "bootia32.efi" + else: + raise WicError("grub-efi is incompatible with target %s" % + target_arch) + + if not os.path.isfile("%s/EFI/BOOT/%s" \ + % (bootimg_dir, grub_image)): + grub_path = get_bitbake_var("STAGING_LIBDIR", "wic-tools") + if not grub_path: + raise WicError("Couldn't find STAGING_LIBDIR, exiting.") + + grub_core = "%s/grub/%s" % (grub_path, grub_target) + if not os.path.exists(grub_core): + raise WicError("Please build grub-efi first") + + grub_cmd = "grub-mkimage -p '/EFI/BOOT' " + grub_cmd += "-d %s " % grub_core + grub_cmd += "-O %s -o %s/EFI/BOOT/%s " \ + % (grub_target, bootimg_dir, grub_image) + grub_cmd += "part_gpt part_msdos ntfs ntfscomp fat ext2 " + grub_cmd += "normal chain boot configfile linux multiboot " + grub_cmd += "search efi_gop efi_uga font gfxterm gfxmenu " + grub_cmd += "terminal minicmd test iorw loadenv echo help " + grub_cmd += "reboot serial terminfo iso9660 loopback tar " + grub_cmd += "memdisk ls search_fs_uuid udf btrfs xfs lvm " + grub_cmd += "reiserfs ata " + exec_native_cmd(grub_cmd, native_sysroot) + + else: + raise WicError("unrecognized bootimg-efi loader: %s" % + source_params['loader']) + except KeyError: + raise WicError("bootimg-efi requires a loader, none specified") + + if os.path.exists("%s/EFI/BOOT" % isodir): + shutil.rmtree("%s/EFI/BOOT" % isodir) + + shutil.copytree(bootimg_dir+"/EFI/BOOT", isodir+"/EFI/BOOT") + + # If exists, remove cr_workdir/bootimg temporary folder + if os.path.exists("%s/bootimg" % cr_workdir): + shutil.rmtree("%s/bootimg" % cr_workdir) + + # Create efi.img that contains bootloader files for EFI booting + # if ISODIR didn't exist or didn't contains it + if os.path.isfile("%s/efi.img" % img_iso_dir): + install_cmd = "install -m 0644 %s/efi.img %s/efi.img" % \ + (img_iso_dir, isodir) + exec_cmd(install_cmd) + else: + du_cmd = "du -bks %s/EFI" % isodir + out = exec_cmd(du_cmd) + blocks = int(out.split()[0]) + # Add some extra space for file system overhead + blocks += 100 + logger.debug("Added 100 extra blocks to %s to get to %d " + "total blocks", part.mountpoint, blocks) + + # dosfs image for EFI boot + bootimg = "%s/efi.img" % isodir + + dosfs_cmd = 'mkfs.vfat -n "EFIimg" -S 512 -C %s %d' \ + % (bootimg, blocks) + exec_native_cmd(dosfs_cmd, native_sysroot) + + mmd_cmd = "mmd -i %s ::/EFI" % bootimg + exec_native_cmd(mmd_cmd, native_sysroot) + + mcopy_cmd = "mcopy -i %s -s %s/EFI/* ::/EFI/" \ + % (bootimg, isodir) + exec_native_cmd(mcopy_cmd, native_sysroot) + + chmod_cmd = "chmod 644 %s" % bootimg + exec_cmd(chmod_cmd) + + # Prepare files for legacy boot + syslinux_dir = get_bitbake_var("STAGING_DATADIR", "wic-tools") + if not syslinux_dir: + raise WicError("Couldn't find STAGING_DATADIR, exiting.") + + if os.path.exists("%s/isolinux" % isodir): + shutil.rmtree("%s/isolinux" % isodir) + + install_cmd = "install -d %s/isolinux" % isodir + exec_cmd(install_cmd) + + cls.do_configure_syslinux(creator, cr_workdir) + + install_cmd = "install -m 444 %s/syslinux/ldlinux.sys " % syslinux_dir + install_cmd += "%s/isolinux/ldlinux.sys" % isodir + exec_cmd(install_cmd) + + install_cmd = "install -m 444 %s/syslinux/isohdpfx.bin " % syslinux_dir + install_cmd += "%s/isolinux/isohdpfx.bin" % isodir + exec_cmd(install_cmd) + + install_cmd = "install -m 644 %s/syslinux/isolinux.bin " % syslinux_dir + install_cmd += "%s/isolinux/isolinux.bin" % isodir + exec_cmd(install_cmd) + + install_cmd = "install -m 644 %s/syslinux/ldlinux.c32 " % syslinux_dir + install_cmd += "%s/isolinux/ldlinux.c32" % isodir + exec_cmd(install_cmd) + + #create ISO image + iso_img = "%s/tempiso_img.iso" % cr_workdir + iso_bootimg = "isolinux/isolinux.bin" + iso_bootcat = "isolinux/boot.cat" + efi_img = "efi.img" + + mkisofs_cmd = "mkisofs -V %s " % part.label + mkisofs_cmd += "-o %s -U " % iso_img + mkisofs_cmd += "-J -joliet-long -r -iso-level 2 -b %s " % iso_bootimg + mkisofs_cmd += "-c %s -no-emul-boot -boot-load-size 4 " % iso_bootcat + mkisofs_cmd += "-boot-info-table -eltorito-alt-boot " + mkisofs_cmd += "-eltorito-platform 0xEF -eltorito-boot %s " % efi_img + mkisofs_cmd += "-no-emul-boot %s " % isodir + + logger.debug("running command: %s", mkisofs_cmd) + exec_native_cmd(mkisofs_cmd, native_sysroot) + + shutil.rmtree(isodir) + + du_cmd = "du -Lbks %s" % iso_img + out = exec_cmd(du_cmd) + isoimg_size = int(out.split()[0]) + + part.size = isoimg_size + part.source_file = iso_img + + @classmethod + def do_install_disk(cls, disk, disk_name, creator, workdir, oe_builddir, + bootimg_dir, kernel_dir, native_sysroot): + """ + Called after all partitions have been prepared and assembled into a + disk image. In this case, we insert/modify the MBR using isohybrid + utility for booting via BIOS from disk storage devices. + """ + + iso_img = "%s.p1" % disk.path + full_path = creator._full_path(workdir, disk_name, "direct") + full_path_iso = creator._full_path(workdir, disk_name, "iso") + + isohybrid_cmd = "isohybrid -u %s" % iso_img + logger.debug("running command: %s", isohybrid_cmd) + exec_native_cmd(isohybrid_cmd, native_sysroot) + + # Replace the image created by direct plugin with the one created by + # mkisofs command. This is necessary because the iso image created by + # mkisofs has a very specific MBR is system area of the ISO image, and + # direct plugin adds and configures an another MBR. + logger.debug("Replaceing the image created by direct plugin\n") + os.remove(disk.path) + shutil.copy2(iso_img, full_path_iso) + shutil.copy2(full_path_iso, full_path) diff --git a/scripts/lib/wic/plugins/source/rawcopy.py b/scripts/lib/wic/plugins/source/rawcopy.py new file mode 100644 index 0000000000..e1c4f5e7db --- /dev/null +++ b/scripts/lib/wic/plugins/source/rawcopy.py @@ -0,0 +1,69 @@ +# ex:ts=4:sw=4:sts=4:et +# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +# + +import logging +import os + +from wic import WicError +from wic.pluginbase import SourcePlugin +from wic.utils.misc import exec_cmd, get_bitbake_var +from wic.filemap import sparse_copy + +logger = logging.getLogger('wic') + +class RawCopyPlugin(SourcePlugin): + """ + Populate partition content from raw image file. + """ + + name = 'rawcopy' + + @classmethod + def do_prepare_partition(cls, part, source_params, cr, cr_workdir, + oe_builddir, bootimg_dir, kernel_dir, + rootfs_dir, native_sysroot): + """ + Called to do the actual content population for a partition i.e. it + 'prepares' the partition to be incorporated into the image. + """ + if not kernel_dir: + kernel_dir = get_bitbake_var("DEPLOY_DIR_IMAGE") + if not kernel_dir: + raise WicError("Couldn't find DEPLOY_DIR_IMAGE, exiting") + + logger.debug('Kernel dir: %s', kernel_dir) + + if 'file' not in source_params: + raise WicError("No file specified") + + src = os.path.join(kernel_dir, source_params['file']) + dst = os.path.join(cr_workdir, "%s.%s" % (source_params['file'], part.lineno)) + + if 'skip' in source_params: + sparse_copy(src, dst, skip=int(source_params['skip'])) + else: + sparse_copy(src, dst) + + # get the size in the right units for kickstart (kB) + du_cmd = "du -Lbks %s" % dst + out = exec_cmd(du_cmd) + filesize = int(out.split()[0]) + + if filesize > part.size: + part.size = filesize + + part.source_file = dst diff --git a/scripts/lib/wic/plugins/source/rootfs.py b/scripts/lib/wic/plugins/source/rootfs.py new file mode 100644 index 0000000000..f2e2ca8a2b --- /dev/null +++ b/scripts/lib/wic/plugins/source/rootfs.py @@ -0,0 +1,125 @@ +# ex:ts=4:sw=4:sts=4:et +# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- +# +# Copyright (c) 2014, Intel Corporation. +# All rights reserved. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +# +# DESCRIPTION +# This implements the 'rootfs' source plugin class for 'wic' +# +# AUTHORS +# Tom Zanussi <tom.zanussi (at] linux.intel.com> +# Joao Henrique Ferreira de Freitas <joaohf (at] gmail.com> +# + +import logging +import os +import shutil + +from oe.path import copyhardlinktree + +from wic import WicError +from wic.pluginbase import SourcePlugin +from wic.utils.misc import get_bitbake_var, exec_cmd + +logger = logging.getLogger('wic') + +class RootfsPlugin(SourcePlugin): + """ + Populate partition content from a rootfs directory. + """ + + name = 'rootfs' + + @staticmethod + def __get_rootfs_dir(rootfs_dir): + if os.path.isdir(rootfs_dir): + return rootfs_dir + + image_rootfs_dir = get_bitbake_var("IMAGE_ROOTFS", rootfs_dir) + if not os.path.isdir(image_rootfs_dir): + raise WicError("No valid artifact IMAGE_ROOTFS from image " + "named %s has been found at %s, exiting." % + (rootfs_dir, image_rootfs_dir)) + + return image_rootfs_dir + + @classmethod + def do_prepare_partition(cls, part, source_params, cr, cr_workdir, + oe_builddir, bootimg_dir, kernel_dir, + krootfs_dir, native_sysroot): + """ + Called to do the actual content population for a partition i.e. it + 'prepares' the partition to be incorporated into the image. + In this case, prepare content for legacy bios boot partition. + """ + if part.rootfs_dir is None: + if not 'ROOTFS_DIR' in krootfs_dir: + raise WicError("Couldn't find --rootfs-dir, exiting") + + rootfs_dir = krootfs_dir['ROOTFS_DIR'] + else: + if part.rootfs_dir in krootfs_dir: + rootfs_dir = krootfs_dir[part.rootfs_dir] + elif part.rootfs_dir: + rootfs_dir = part.rootfs_dir + else: + raise WicError("Couldn't find --rootfs-dir=%s connection or " + "it is not a valid path, exiting" % part.rootfs_dir) + + real_rootfs_dir = cls.__get_rootfs_dir(rootfs_dir) + + # Handle excluded paths. + if part.exclude_path is not None: + # We need a new rootfs directory we can delete files from. Copy to + # workdir. + new_rootfs = os.path.realpath(os.path.join(cr_workdir, "rootfs")) + + if os.path.lexists(new_rootfs): + shutil.rmtree(os.path.join(new_rootfs)) + + copyhardlinktree(real_rootfs_dir, new_rootfs) + + real_rootfs_dir = new_rootfs + + for orig_path in part.exclude_path: + path = orig_path + if os.path.isabs(path): + msger.error("Must be relative: --exclude-path=%s" % orig_path) + + full_path = os.path.realpath(os.path.join(new_rootfs, path)) + + # Disallow climbing outside of parent directory using '..', + # because doing so could be quite disastrous (we will delete the + # directory). + if not full_path.startswith(new_rootfs): + msger.error("'%s' points to a path outside the rootfs" % orig_path) + + if path.endswith(os.sep): + # Delete content only. + for entry in os.listdir(full_path): + full_entry = os.path.join(full_path, entry) + if os.path.isdir(full_entry) and not os.path.islink(full_entry): + shutil.rmtree(full_entry) + else: + os.remove(full_entry) + else: + # Delete whole directory. + shutil.rmtree(full_path) + + part.rootfs_dir = real_rootfs_dir + part.prepare_rootfs(cr_workdir, oe_builddir, + real_rootfs_dir, native_sysroot) diff --git a/scripts/lib/mic/imager/__init__.py b/scripts/lib/wic/utils/__init__.py index e69de29bb2..e69de29bb2 100644 --- a/scripts/lib/mic/imager/__init__.py +++ b/scripts/lib/wic/utils/__init__.py diff --git a/scripts/lib/wic/utils/misc.py b/scripts/lib/wic/utils/misc.py new file mode 100644 index 0000000000..46099840ca --- /dev/null +++ b/scripts/lib/wic/utils/misc.py @@ -0,0 +1,230 @@ +# ex:ts=4:sw=4:sts=4:et +# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- +# +# Copyright (c) 2013, Intel Corporation. +# All rights reserved. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +# +# DESCRIPTION +# This module provides a place to collect various wic-related utils +# for the OpenEmbedded Image Tools. +# +# AUTHORS +# Tom Zanussi <tom.zanussi (at] linux.intel.com> +# +"""Miscellaneous functions.""" + +import logging +import os +import re + +from collections import defaultdict +from distutils import spawn + +from wic import WicError +from wic.utils import runner + +logger = logging.getLogger('wic') + +# executable -> recipe pairs for exec_native_cmd +NATIVE_RECIPES = {"bmaptool": "bmap-tools", + "grub-mkimage": "grub-efi", + "isohybrid": "syslinux", + "mcopy": "mtools", + "mkdosfs": "dosfstools", + "mkisofs": "cdrtools", + "mkfs.btrfs": "btrfs-tools", + "mkfs.ext2": "e2fsprogs", + "mkfs.ext3": "e2fsprogs", + "mkfs.ext4": "e2fsprogs", + "mkfs.vfat": "dosfstools", + "mksquashfs": "squashfs-tools", + "mkswap": "util-linux", + "mmd": "syslinux", + "parted": "parted", + "sfdisk": "util-linux", + "sgdisk": "gptfdisk", + "syslinux": "syslinux" + } + +def _exec_cmd(cmd_and_args, as_shell=False): + """ + Execute command, catching stderr, stdout + + Need to execute as_shell if the command uses wildcards + """ + logger.debug("_exec_cmd: %s", cmd_and_args) + args = cmd_and_args.split() + logger.debug(args) + + if as_shell: + ret, out = runner.runtool(cmd_and_args) + else: + ret, out = runner.runtool(args) + out = out.strip() + if ret != 0: + raise WicError("_exec_cmd: %s returned '%s' instead of 0\noutput: %s" % \ + (cmd_and_args, ret, out)) + + logger.debug("_exec_cmd: output for %s (rc = %d): %s", + cmd_and_args, ret, out) + + return ret, out + + +def exec_cmd(cmd_and_args, as_shell=False): + """ + Execute command, return output + """ + return _exec_cmd(cmd_and_args, as_shell)[1] + + +def exec_native_cmd(cmd_and_args, native_sysroot, pseudo=""): + """ + Execute native command, catching stderr, stdout + + Need to execute as_shell if the command uses wildcards + + Always need to execute native commands as_shell + """ + # The reason -1 is used is because there may be "export" commands. + args = cmd_and_args.split(';')[-1].split() + logger.debug(args) + + if pseudo: + cmd_and_args = pseudo + cmd_and_args + + wtools_sysroot = get_bitbake_var("RECIPE_SYSROOT_NATIVE", "wic-tools") + + native_paths = \ + "%s/sbin:%s/usr/sbin:%s/usr/bin:%s/sbin:%s/usr/sbin:%s/usr/bin" % \ + (wtools_sysroot, wtools_sysroot, wtools_sysroot, + native_sysroot, native_sysroot, native_sysroot) + native_cmd_and_args = "export PATH=%s:$PATH;%s" % \ + (native_paths, cmd_and_args) + logger.debug("exec_native_cmd: %s", native_cmd_and_args) + + # If the command isn't in the native sysroot say we failed. + if spawn.find_executable(args[0], native_paths): + ret, out = _exec_cmd(native_cmd_and_args, True) + else: + ret = 127 + out = "can't find native executable %s in %s" % (args[0], native_paths) + + prog = args[0] + # shell command-not-found + if ret == 127 \ + or (pseudo and ret == 1 and out == "Can't find '%s' in $PATH." % prog): + msg = "A native program %s required to build the image "\ + "was not found (see details above).\n\n" % prog + recipe = NATIVE_RECIPES.get(prog) + if recipe: + msg += "Please make sure wic-tools have %s-native in its DEPENDS, bake it with 'bitbake wic-tools' "\ + "and try again.\n" % recipe + else: + msg += "Wic failed to find a recipe to build native %s. Please "\ + "file a bug against wic.\n" % prog + raise WicError(msg) + + return ret, out + +BOOTDD_EXTRA_SPACE = 16384 + +class BitbakeVars(defaultdict): + """ + Container for Bitbake variables. + """ + def __init__(self): + defaultdict.__init__(self, dict) + + # default_image and vars_dir attributes should be set from outside + self.default_image = None + self.vars_dir = None + + def _parse_line(self, line, image, matcher=re.compile(r"^(\w+)=(.+)")): + """ + Parse one line from bitbake -e output or from .env file. + Put result key-value pair into the storage. + """ + if "=" not in line: + return + match = matcher.match(line) + if not match: + return + key, val = match.groups() + self[image][key] = val.strip('"') + + def get_var(self, var, image=None, cache=True): + """ + Get bitbake variable from 'bitbake -e' output or from .env file. + This is a lazy method, i.e. it runs bitbake or parses file only when + only when variable is requested. It also caches results. + """ + if not image: + image = self.default_image + + if image not in self: + if image and self.vars_dir: + fname = os.path.join(self.vars_dir, image + '.env') + if os.path.isfile(fname): + # parse .env file + with open(fname) as varsfile: + for line in varsfile: + self._parse_line(line, image) + else: + print("Couldn't get bitbake variable from %s." % fname) + print("File %s doesn't exist." % fname) + return + else: + # Get bitbake -e output + cmd = "bitbake -e" + if image: + cmd += " %s" % image + + log_level = logger.getEffectiveLevel() + logger.setLevel(logging.INFO) + ret, lines = _exec_cmd(cmd) + logger.setLevel(log_level) + + if ret: + logger.error("Couldn't get '%s' output.", cmd) + logger.error("Bitbake failed with error:\n%s\n", lines) + return + + # Parse bitbake -e output + for line in lines.split('\n'): + self._parse_line(line, image) + + # Make first image a default set of variables + if cache: + images = [key for key in self if key] + if len(images) == 1: + self[None] = self[image] + + result = self[image].get(var) + if not cache: + self.pop(image, None) + + return result + +# Create BB_VARS singleton +BB_VARS = BitbakeVars() + +def get_bitbake_var(var, image=None, cache=True): + """ + Provide old get_bitbake_var API by wrapping + get_var method of BB_VARS singleton. + """ + return BB_VARS.get_var(var, image, cache) diff --git a/scripts/lib/wic/utils/runner.py b/scripts/lib/wic/utils/runner.py new file mode 100644 index 0000000000..4aa00fbe20 --- /dev/null +++ b/scripts/lib/wic/utils/runner.py @@ -0,0 +1,52 @@ +#!/usr/bin/env python -tt +# +# Copyright (c) 2011 Intel, Inc. +# +# This program is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by the Free +# Software Foundation; version 2 of the License +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY +# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., 59 +# Temple Place - Suite 330, Boston, MA 02111-1307, USA. +import subprocess + +from wic import WicError + +def runtool(cmdln_or_args): + """ wrapper for most of the subprocess calls + input: + cmdln_or_args: can be both args and cmdln str (shell=True) + return: + rc, output + """ + if isinstance(cmdln_or_args, list): + cmd = cmdln_or_args[0] + shell = False + else: + import shlex + cmd = shlex.split(cmdln_or_args)[0] + shell = True + + sout = subprocess.PIPE + serr = subprocess.STDOUT + + try: + process = subprocess.Popen(cmdln_or_args, stdout=sout, + stderr=serr, shell=shell) + sout, serr = process.communicate() + # combine stdout and stderr, filter None out and decode + out = ''.join([out.decode('utf-8') for out in [sout, serr] if out]) + except OSError as err: + if err.errno == 2: + # [Errno 2] No such file or directory + raise WicError('Cannot run command: %s, lost dependency?' % cmd) + else: + raise # relay + + return process.returncode, out |