Adding EPL version of configurationengine.
#
# Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
# All rights reserved.
# This component and the accompanying materials are made available
# under the terms of "Eclipse Public License v1.0"
# which accompanies this distribution, and is available
# at the URL "http://www.eclipse.org/legal/epl-v10.html".
#
# Initial Contributors:
# Nokia Corporation - initial contribution.
#
# Contributors:
#
# Description:
#
import os
import sys
import logging
from optparse import OptionParser, OptionGroup
import codecs
import cone_common
import time
from cone.public import api, plugin, utils, exceptions
from time import gmtime, strftime
import report_util
ROOT_PATH = os.path.dirname(os.path.abspath(__file__))
VERSION = '1.0'
log = logging.getLogger('cone')
REPORT_SHORTCUTS = {
'api': report_util.ReportShortcut(
os.path.join(ROOT_PATH, 'compare_api_report_template.html'),
'api_comparison.html',
'Report changes in feature definitions'),
'data': report_util.ReportShortcut(
os.path.join(ROOT_PATH, 'compare_data_report_template.html'),
'data_comparison.html',
'Report changes in data values'),
'crml_dc': report_util.ReportShortcut(
os.path.join(ROOT_PATH, 'crml_dc_report_template.html'),
'crml_dc_report.html',
'Report CRML data compatibility issues'),
'crml_dc_csv': report_util.ReportShortcut(
os.path.join(ROOT_PATH, 'crml_dc_report_template.csv'),
'crml_dc_report.csv',
'Report CRML data compatibility issues (CSV format)'),
}
DEFAULT_SHORTCUT = 'data'
def main():
shortcut_container = report_util.ReportShortcutContainer(REPORT_SHORTCUTS,
DEFAULT_SHORTCUT)
gset = cone_common.get_settings([os.path.join(ROOT_PATH,'conesub_compare.cfg')])
parser = OptionParser(version="%%prog %s" % VERSION)
parser.add_options(cone_common.COMMON_OPTIONS)
parser.add_option("-p", "--project",\
dest="project",\
help="defines the location of current project. Default is the current working directory.",\
default=".",\
metavar="STORAGE")
group = OptionGroup(parser, 'Compare options',
'The generate function will create target files from a specific configuration.'\
'The generate will always work with read-only mode of the project, so no changes are saved to project')
group.add_option("-s", "--sourceconfiguration",\
dest="sourceconfiguration",\
help="defines the name of the sourceconfiguration for the compare action. "\
"The configuration is expected to be located current storage.",\
metavar="CONFIG")
group.add_option("-t", "--targetconfiguration",\
dest="targetconfiguration",\
help="defines the name of the target configuration for the compare action. "\
"The configuration can be located in the current storage or it the configuration"\
"definition can contain a path to a storage. The storage definition is given as a path"\
"before semicolon. e.g. x:\data\configproject;productx.confml, test.cpf;root.confml",\
metavar="CONFIG")
# group.add_option("--compare-dict",\
# dest="compare_dict",\
# action="store",
# type="string",
# help="Compare elements as a dictionary",
# metavar="DICT",\
# default=None)
group.add_option("--report",\
dest="report_file",\
action="store",
type="string",
help="The file where the comparison report is written."\
"By default this value is determined by the used "\
"report type. Example: --report report.html.",
metavar="FILE",\
default=None)
group.add_option("--template",\
dest="template",\
action="store",
type="string",
help="Template used in a report generation. By default "\
"this value is determined by the used report type. "\
"Example: --template report_template.html.",
metavar="FILE",\
default=None)
group.add_option("--report-type",
dest="report_type",
action="store",
type="string",
help="The type of the report to generate. This is a convenience "\
"switch for setting the used template. "\
"Possible values:\n "\
+ shortcut_container.get_shortcut_help_text(),
metavar="TYPE",\
default=None)
group.add_option("--impl-filter",\
dest="impl_filter",\
action="store",
type="string",
help="The pattern used for filtering implementations for the "\
"comparison. See the switch --impl in action generate for "\
"more info. ",
metavar="PATTERN",\
default=None)
start_time = time.time()
parser.add_option_group(group)
(options, args) = parser.parse_args()
cone_common.handle_common_options(options, settings=gset)
if not options.sourceconfiguration: parser.error("sourceconfiguration must be given")
if not options.targetconfiguration: parser.error("targetconfiguration must be given")
if options.report_type and options.template:
parser.error("both --report-type and --template supplied; use only one of them")
if not shortcut_container.is_valid_shortcut(options.report_type):
parser.error("Invalid report type: %s" % options.report_type)
template_file, report_file = shortcut_container.determine_template_and_report(
options.report_type,
options.template,
options.report_file,
'comparison')
action = CompareAction(options.project,
options.sourceconfiguration,
options.targetconfiguration,
template = template_file,
report_file = report_file,
impl_filter = options.impl_filter)
result = action.run_action()
resmap = {True: 0, False: 1}
sys.exit(resmap[result])
class CompareAction(object):
def __init__(self, current, sourceconfig, targetconfig, **kwargs):
self.current = current
self.sourceconfig = sourceconfig
self.targetconfig = targetconfig
self.reportfile = kwargs.get("report_file", 'compare.html')
self.reporttemplate = kwargs.get('template', '')
self.columns = kwargs.get('columns', None)
self.impl_filter = kwargs.get('impl_filter',)
def run_action(self):
"""
Run the action.
@return: True if successful, False if not.
"""
currentprj = api.Project(api.Storage.open(self.current,"r"))
targetprj = None
(targetproject,targetconf) = self.parse_target_configuration(self.targetconfig)
print "Compare %s <> %s in %s" % (self.sourceconfig, targetconf, targetproject)
if targetproject != '':
targetprj = api.Project(api.Storage.open(targetproject,"r"))
else:
# The comparison doesn't seem to work if the same project
# object is used
#targetprj = currentprj
targetprj = api.Project(api.Storage.open(self.current,"r"))
source = currentprj.get_configuration(self.sourceconfig)
target = targetprj.get_configuration(targetconf)
print "Writing report to %s" % self.reportfile
sourcedata = {}
targetdata = {}
sourcedata['name'] = self.sourceconfig
targetdata['name'] = self.targetconfig
sourcedata['features'] = self.get_feature_api_data(source)
targetdata['features'] = self.get_feature_api_data(target)
impl_comp_data_proxy = ImplComparisonDataProxy(source,
target,
self.impl_filter)
template_data = {'sourcedata': sourcedata,
'targetdata': targetdata,
'impl_data': impl_comp_data_proxy}
result = report_util.generate_report(self.reporttemplate,
self.reportfile,
{'data': template_data})
print "Done."
return result
def parse_target_configuration(self,configpath):
"""
return tuple (storage, configpath) from storagepath;root.confml.
returns ('', 'root.confml') from root.confml
"""
elems = configpath.rsplit(';',2)
if len(elems) > 1:
return (elems[0],elems[1])
else:
return ('',elems[0])
def get_feature_api_data(self,config):
# Traverse through all features in the api
# and construct the data rows
data = {}
for elem in config.get_default_view().get_features('**'):
data[elem.fqr] = elem._obj
return data
class ImplComparisonDataProxy(object):
"""
Proxy object for loading implementation comparison data on demand.
"""
def __init__(self, sourceconfig, targetconfig, impl_filter):
self.sourceconfig = sourceconfig
self.targetconfig = targetconfig
if impl_filter is None: self.impl_filter = '.*'
else: self.impl_filter = impl_filter
self._flat_data = None
@property
def flat(self):
try:
if self._flat_data is None:
self._flat_data = self._get_flat_comparison_data()
return self._flat_data
except Exception, e:
utils.log_exception(log, 'Error retrieving ImplComparisonDataProxy.flat!')
raise
def _get_flat_comparison_data(self):
log.debug("Loading implementations for comparison (impl filter = '%s')..." % (self.impl_filter))
try:
source_impls = plugin.get_impl_set(self.sourceconfig, self.impl_filter)
target_impls = plugin.get_impl_set(self.targetconfig, self.impl_filter)
except Exception, e:
utils.log_exception(log, 'Failed to load implementations!')
raise
log.debug("%d impl(s) in source." % len(source_impls))
log.debug("%d impl(s) in target." % len(target_impls))
log.debug("Generating flat comparison results...")
result = source_impls.flat_compare(target_impls)
log.debug("Generated %d result row(s)" % len(result))
return result
if __name__ == "__main__":
main()