def test_import_dir_with_no_tests(self):
host = MockHost()
host.executive = MockExecutive2(exception=ScriptError(
"abort: no repository found in '/Volumes/Source/src/wk/Tools/Scripts/webkitpy/w3c' (.hg not found)!"
))
host.filesystem = MockFileSystem(files=FAKE_FILES)
importer = TestImporter(
host, FAKE_SOURCE_DIR, FAKE_REPO_DIR,
optparse.Values({
"overwrite": False,
'destination': 'w3c'
}))
oc = OutputCapture()
oc.capture_output()
try:
importer.do_import()
finally:
oc.restore_output()
def run(self):
logging.info('Monitoring process ID: %s' % self.process_id)
self.debugger = SyscallTracer(
options=optparse.Values({
'fork': False,
'enter': False,
'show_ip': False,
'trace_exec': True,
'no_stdout': False,
'pid': self.process_id,
'show_pid': True,
}),
program=None,
ignore_syscall_callback=self.ignore_syscall_callback,
syscall_callback=self.syscall_callback,
event_callback=self.event_callback,
quit_callback=self.quit_callback)
self.debugger.main()
def test_lint_test_files__errors(self):
options = optparse.Values({'platform': 'test', 'debug_rwt_logging': False})
host = MockHost()
# FIXME: incorrect complaints about spacing pylint: disable=C0322
port = host.port_factory.get(options.platform, options=options)
port.expectations_dict = lambda: {'foo': '-- syntax error1', 'bar': '-- syntax error2'}
host.port_factory.get = lambda platform, options=None: port
host.port_factory.all_port_names = lambda platform=None: [port.name()]
logging_stream = StringIO.StringIO()
res = lint_test_expectations.lint(host, options, logging_stream)
self.assertEqual(res, -1)
self.assertIn('Lint failed', logging_stream.getvalue())
self.assertIn('foo:1', logging_stream.getvalue())
self.assertIn('bar:1', logging_stream.getvalue())
def test_server_fails_to_start_throws_exception(self):
host = MockHost()
options = optparse.Values()
options.ensure_value("results_directory", "/mock/output_dir")
port = Port(host, "test", options)
server = WebPlatformTestServer(port, "wpttest",
"/mock/output_dir/pid.txt")
server._check_that_all_ports_are_available = lambda: True
server._is_server_running_on_all_ports = lambda: True
host.filesystem.write_text_file(
"/mock-checkout/LayoutTests/resources/testharness.js", "0")
host.filesystem.write_text_file(
"/mock-checkout/LayoutTests/imported/w3c/web-platform-tests/resources/testharness.js",
"0")
server.start()
server.stop()
server._process.poll = lambda: 1
self.assertRaises(ServerError, server.start)
def assert_execute_outputs(
self, command, args=None, expected_stdout="", expected_stderr="",
expected_exception=None, expected_logs=None, options=optparse.Values(), tool=MockWebKitPatch()):
args = args or []
options.blocks = None
options.cc = 'MOCK cc'
options.component = 'MOCK component'
options.confirm = True
options.email = 'MOCK email'
options.git_commit = 'MOCK git commit'
options.obsolete_patches = True
options.open_bug = True
options.port = 'MOCK port'
options.update_changelogs = False
options.quiet = True
options.reviewer = 'MOCK reviewer'
OutputCapture().assert_outputs(
self, command.execute, [options, args, tool], expected_stdout=expected_stdout,
expected_stderr=expected_stderr, expected_exception=expected_exception, expected_logs=expected_logs)
def format_parameters(self):
self.keyname = self.novaclient.keypairs.list().pop().name
self.testcase.assertTrue(self.heatclient)
full_paramstr = ';'.join([self.stack_paramstr,
'KeyName=' + self.keyname,
'LinuxDistribution=' + self.distribution])
template_params = optparse.Values({'parameters': full_paramstr})
# Format parameters and create the stack
parameters = {}
parameters['StackName'] = self.stackname
template_path = os.path.join(basepath,
'templates',
self.template_file)
parameters['TemplateBody'] = open(template_path).read()
parameters.update(self.heatclient.format_parameters(template_params))
return parameters
def test_import_dir_with_no_tests_and_no_hg(self):
host = MockHost()
host.executive = MockExecutive2(exception=OSError())
host.filesystem = MockFileSystem(files=FAKE_FILES)
importer = TestImporter(
host, FAKE_SOURCE_DIR,
optparse.Values({
"overwrite": False,
'destination': 'w3c',
'test_paths': [FAKE_TEST_PATH]
}))
oc = OutputCapture()
oc.capture_output()
try:
importer.do_import()
finally:
oc.restore_output()
def inject_options(roles, options):
new_options = optparse.Values(options.__dict__)
for key in ('ignore', 'select'):
if 'set-' + key in roles:
values = [
value.strip() for value in roles['set-' + key].split(',')
]
setattr(new_options, key, values)
if 'add-' + key in roles:
values = {
value.strip()
for value in roles['add-' + key].split(',')
}
values.update(new_options.__dict__[key])
setattr(new_options, key, list(values))
return new_options
def rtactivate(nameserver, tags):
def activate_action(object, ec_index):
object.activate_in_ec(ec_index)
for tag in tags:
# check if/unless attribute in rtactivate tags
exec_flag = True
if tag.attributes.get(u'if'):
val = tag.attributes.get(u'if').value
arg = val.split(" ")[1].strip(")") # To "USE_WALKING"
exec_flag = get_flag_from_argv(arg)
if tag.attributes.get(u'unless'):
val = tag.attributes.get(u'unless').value
arg = val.split(" ")[1].strip(")") # To "USE_WALKING"
exec_flag = not get_flag_from_argv(arg)
if not exec_flag:
continue
cmd_path = nameserver + "/" + tag.attributes.get("component").value
full_path = path.cmd_path_to_full_path(cmd_path)
# print >>sys.stderr, "[rtmlaunch] activate %s"%(full_path)
try:
state = wait_component(full_path)
if state == 'Active':
continue
else:
print >> sys.stderr, "[rtmlaunch] Activate <-", state, full_path
except Exception, e:
print >> sys.stderr, '\033[31m[rtmlaunch] Could not Activate (', cmd_path, ') : ', e, '\033[0m'
return 1
try:
options = optparse.Values({"ec_index": 0, 'verbose': False})
try:
state_control_base.alter_component_state(
activate_action, cmd_path, full_path, options, None)
except Exception, e: # openrtm 1.1.0
state_control_base.alter_component_states(
activate_action, [(cmd_path, full_path)], options, None)
except Exception, e:
print >> sys.stderr, '[rtmlaunch] {0}: {1}'.format(
os.path.basename(sys.argv[0]), e)
return 1
def test_corrupted_subserver_files(self):
host = MockHost()
options = optparse.Values()
options.ensure_value("results_directory", "/mock/output_dir")
port = Port(host, "test", options)
server = WebPlatformTestServer(port, "wpttest",
"/mock/output_dir/pid.txt")
server._check_that_all_ports_are_available = lambda: True
server._is_server_running_on_all_ports = lambda: True
host.filesystem.write_text_file(
"/mock-checkout/LayoutTests/resources/testharness.js", "0")
host.filesystem.write_text_file(
"/mock-checkout/LayoutTests/imported/w3c/web-platform-tests/resources/testharness.js",
"0")
host.filesystem.write_text_file(
"/mock_output_dir/wpttest_servers.json", "0")
server.stop()
self.assertFalse(
host.filesystem.exists("/mock/output_dir/wpttest_servers.json"))
host.filesystem.write_text_file(
"/mock_output_dir/wpttest_servers.json", "[0,")
server.start()
self.assertFalse(
host.filesystem.exists("/mock/output_dir/wpttest_servers.json"))
server.stop()
host.filesystem.write_text_file(
"/mock_output_dir/wpttest_servers.json",
"[{'protocol': 'http', 'port': 80 }]")
server.start()
self.assertFalse(
host.filesystem.exists("/mock/output_dir/wpttest_servers.json"))
server.stop()
host.filesystem.write_text_file(
"/mock_output_dir/wpttest_servers.json",
"[{'protocol': 'http', 'port': 80, 'pid': {} }]")
server.start()
self.assertFalse(
host.filesystem.exists("/mock/output_dir/wpttest_servers.json"))
server.stop()
def test_default_expectations_ordering(self):
port = self.make_port()
for path in port.default_expectations_files():
port.host.filesystem.write_text_file(path, '')
ordered_dict = port.expectations_dict()
self.assertEqual(port.path_to_generic_test_expectations_file(),
list(ordered_dict)[0])
options = optparse.Values(
dict(additional_expectations=['/tmp/foo', '/tmp/bar']))
port = self.make_port(options=options)
for path in port.default_expectations_files():
port.host.filesystem.write_text_file(path, '')
port.host.filesystem.write_text_file('/tmp/foo', 'foo')
port.host.filesystem.write_text_file('/tmp/bar', 'bar')
ordered_dict = port.expectations_dict()
self.assertEqual(
list(ordered_dict)[-2:], options.additional_expectations)
self.assertEqual(list(ordered_dict.values())[-2:], ['foo', 'bar'])
def test_only_wpt_in_android_override_files(self):
options = optparse.Values({
'additional_expectations': [],
'platform': 'test',
'debug_rwt_logging': False
})
host = MockHost()
port = host.port_factory.get(options.platform, options=options)
raw_expectations = ('# results: [ Failure ]\n'
'external/wpt/test.html [ Failure ]\n'
'non-wpt/test.html [ Failure ]\n')
for path in PRODUCTS_TO_EXPECTATION_FILE_PATHS.values():
host.filesystem.write_text_file(path, raw_expectations)
host.port_factory.get = lambda platform, options=None: port
host.port_factory.all_port_names = lambda platform=None: [port.name()]
port.test_exists = lambda _: True
port.tests = lambda _: {'external/wpt/test.html', 'non-wpt/test.html'}
failures, _ = lint_test_expectations.lint(host, options)
self.assertTrue(all('is for a non WPT test' in f for f in failures))
def __init__(self,
stdin="/dev/null",
stdout="/dev/null",
stderr="/dev/null",
conf="./insync.conf",
pidfile=None,
user=None,
group=None):
options = dict(
stdin=stdin,
stdout=stdout,
stderr=stderr,
pidfile=pidfile,
user=user,
group=group,
conf=conf,
)
self.options = optparse.Values(options)
def _TestArguments(self, force):
opts = optparse.Values(
dict(status_filter=None, force=force, kill=False))
def _CancelCb(job_id):
self.assertTrue(job_id in ("24185", "3252"))
return (True, "%s will be cancelled" % job_id)
cl = _ClientForCancelJob(_CancelCb, NotImplemented)
self.assertEqual(
gnt_job.CancelJobs(opts, ["24185", "3252"],
cl=cl,
_stdout_fn=self._ToStdout,
_ask_fn=NotImplemented), constants.EXIT_SUCCESS)
self.assertEqual(cl.cancelled, ["24185", "3252"])
self.assertEqual(self.stdout, [
"24185 will be cancelled",
"3252 will be cancelled",
])
def parse_dest(self, dest):
try:
dest, ssl = re.subn("^imaps:", "imap:", dest)
dest = urlparse(dest)
options = optparse.Values()
options.ssl = bool(ssl)
options.host = dest.hostname
options.port = [143, 993][options.ssl]
if dest.port:
options.port = dest.port
if dest.username:
options.user = urllib.unquote(dest.username)
if dest.password:
options.password = urllib.unquote(dest.password)
if len(dest.path):
options.box = dest.path[1:] # trim the first `/'
return options
except:
self.error("Invalid DEST")
def test_rebaseline_test_internal_with_port_that_lacks_buildbot(self):
self.tool.executive = MockExecutive()
port = self.tool.port_factory.get('test-win-win7')
self._write(
port.host.filesystem.join(
port.layout_tests_dir(),
'platform/test-win-win10/failures/expected/image-expected.txt'
), 'original win10 result')
oc = OutputCapture()
try:
options = optparse.Values({
'optimize': True,
'builder': 'MOCK Win10',
'port_name': None,
'suffixes': 'txt',
'verbose': True,
'test': 'failures/expected/image.html',
'results_directory': None,
'build_number': None
})
oc.capture_output()
self.command.execute(options, [], self.tool)
finally:
out, _, _ = oc.restore_output()
self.assertMultiLineEqual(
self._read(
self.tool.filesystem.join(
port.layout_tests_dir(),
'platform/test-win-win10/failures/expected/image-expected.txt'
)), 'MOCK Web result, convert 404 to None=True')
self.assertFalse(
self.tool.filesystem.exists(
self.tool.filesystem.join(
port.layout_tests_dir(),
'platform/test-win-win7/failures/expected/image-expected.txt'
)))
self.assertMultiLineEqual(
out,
'{"remove-lines": [{"test": "failures/expected/image.html", "port_name": "test-win-win10"}]}\n'
)
def test_rebaseline_test_internal_with_port_that_lacks_buildbot(self):
self.tool.executive = MockExecutive()
port = self.tool.port_factory.get('test-win-win7')
baseline_relative_path = 'platform/test-win-win10/failures/expected/image-expected.txt'
baseline_local_absolute_path = port.host.filesystem.join(
port.web_tests_dir(), baseline_relative_path)
self._write(baseline_local_absolute_path, 'original win10 result')
actual_result_url = (
'https://test-results.appspot.com/data/layout_results/MOCK_Win10/'
+ 'results/layout-test-results/failures/expected/image-actual.txt')
self.tool.web.urls[actual_result_url] = 'new win10 result'
oc = OutputCapture()
try:
options = optparse.Values({
'optimize': True,
'builder': 'MOCK Win10',
'port_name': None,
'suffixes': 'txt',
'verbose': True,
'test': 'failures/expected/image.html',
'results_directory': None,
'build_number': None,
'step_name': None,
'flag_specific': None,
})
oc.capture_output()
self.command.execute(options, [], self.tool)
finally:
out, _, _ = oc.restore_output()
self.assertItemsEqual(self.tool.web.urls_fetched, [actual_result_url])
self.assertMultiLineEqual(self._read(baseline_local_absolute_path),
'new win10 result')
self.assertFalse(
self.tool.filesystem.exists(
self.tool.filesystem.join(
port.web_tests_dir(),
'platform/test-win-win7/failures/expected/image-expected.txt'
)))
# We should not change TestExpectations for unexpected failures.
self.assertMultiLineEqual(out, '')
def handle_args(argv):
"""Gets the config name from the command line arguments."""
if len(argv) <= 1:
usage('Must specify a config.')
if argv[1] in ('-h', '--help', 'help'):
usage()
dry_run = False
nohooks = False
no_history = False
force = False
while len(argv) >= 2:
arg = argv[1]
if not arg.startswith('-'):
break
argv.pop(1)
if arg in ('-n', '--dry-run'):
dry_run = True
elif arg == '--nohooks':
nohooks = True
elif arg == '--no-history':
no_history = True
elif arg == '--force':
force = True
else:
usage('Invalid option %s.' % arg)
def looks_like_arg(arg):
return arg.startswith('--') and arg.count('=') == 1
bad_parms = [x for x in argv[2:] if not looks_like_arg(x)]
if bad_parms:
usage('Got bad arguments %s' % bad_parms)
config = argv[1]
props = argv[2:]
return (optparse.Values({
'dry_run': dry_run,
'nohooks': nohooks,
'no_history': no_history,
'force': force
}), config, props)
def test_virtual_test_redundant_expectation(self):
options = optparse.Values({
'additional_expectations': [],
'platform': 'test',
'debug_rwt_logging': False
})
host = MockHost()
port = host.port_factory.get(options.platform, options=options)
port.virtual_test_suites = lambda: [
VirtualTestSuite(
prefix='foo', bases=['test', 'external/wpt'], args=['--foo'])
]
test_expectations = (
'# tags: [ mac win ]\n'
'# tags: [ debug release ]\n'
'# results: [ Failure Pass ]\n'
'[ mac ] test/test1.html [ Failure ]\n'
'[ mac debug ] virtual/foo/test/test1.html [ Failure ]\n'
'[ win ] virtual/foo/test/test1.html [ Failure ]\n'
'[ mac release ] virtual/foo/test/test1.html [ Pass ]\n'
'test/test2.html [ Failure ]\n'
'crbug.com/1234 virtual/foo/test/test2.html [ Failure ]\n'
'test/subtest/test2.html [ Failure ]\n'
'virtual/foo/test/subtest/* [ Pass ]\n'
'virtual/foo/test/subtest/test2.html [ Failure ]\n'
'external/wpt/wpt.html [ Failure ]\n'
# TODO(crbug.com/1080691): This is redundant with the above one, but
# for now we intentially ignore it.
'virtual/foo/external/wpt/wpt.html [ Failure ]\n')
port.expectations_dict = lambda: {
'testexpectations': test_expectations
}
port.test_exists = lambda test: True
host.port_factory.get = lambda platform=None, options=None: port
host.port_factory.all_port_names = lambda platform=None: [port.name()]
failures, warnings = lint_test_expectations.lint(host, options)
self.assertEqual(failures, [])
self.assertEquals(len(warnings), 1)
self.assertRegexpMatches(warnings[0], ':5 .*redundant with.* line 4$')
def test_extra_files_errors(self):
options = optparse.Values({
'platform': 'test',
'debug_rwt_logging': False
})
host = MockHost()
port = host.port_factory.get(options.platform, options=options)
port.expectations_dict = lambda: {}
host.port_factory.get = lambda platform, options=None: port
host.port_factory.all_port_names = lambda platform=None: [port.name()]
host.filesystem.write_text_file(
'/test.checkout/wtests/LeakExpectations', '-- syntax error')
res = lint_test_expectations.lint(host, options)
self.assertTrue(res)
all_logs = ''.join(self.logMessages())
self.assertIn('LeakExpectations:1', all_logs)
def get_parsed_args():
parser = optparse.OptionParser()
parser.add_option('-c',
'--clean',
action='store_true',
default=False,
dest='clean')
parser.add_option('-v',
'--verbose',
action='store_true',
default=False,
dest='verbose',
help='Print out stacktraces for errors in checks')
try:
options, args = parser.parse_args()
except SystemExit:
# Ignore parse errors
options, args = optparse.Values({'clean': False}), []
return options, args
def dropIndexes(self):
if len(self.index_create_cmds) > 0:
popup_message(
"Index drop previously executed",
"A prior execution of index drop has been detected. This invocation is aborted."
)
return
opts = self.dbPane.getDbOptions()
dbConn = getDbConnection(optparse.Values(opts))
indexes = dbConn.execute(
"SELECT (schemaname || '.' || indexname) index_name, indexdef index_create_cmd \
FROM pg_indexes \
WHERE tablename = 'v_fact_data' AND indexname NOT LIKE 'v_fact_data_test_pkey'"
)
for index in indexes:
self.index_create_cmds.append(index.index_create_cmd)
dbConn.execute("DROP INDEX %s" % index.index_name)
dbConn.close()
def test_process(self):
self.create('somechannel-20130316.log')
self.create('somechannel-20130316.log.html')
self.create('somechannel-20130317.log')
self.create('somechannel-20130318.log')
options = optparse.Values(dict(searchbox=True, dircproxy=True,
pattern='*.log', force=False,
prefix='IRC logs for ', output_dir=None,
style='xhtmltable', title='IRC logs'))
process(self.tmpdir, options)
self.assertTrue(os.path.exists(self.filename('index.html')))
if hasattr(os, 'symlink'):
self.assertTrue(os.path.exists(self.filename('latest.log.html')))
self.assertTrue(os.path.exists(self.filename('irclog.css')))
self.assertTrue(os.path.exists(
self.filename('somechannel-20130316.log.html')))
self.assertTrue(os.path.exists(
self.filename('somechannel-20130317.log.html')))
self.assertTrue(os.path.exists(
self.filename('somechannel-20130318.log.html')))
def configure_pg_hba_ambaridb_users():
args = optparse.Values()
configure_postgres_username_password(args)
with open(PG_HBA_CONF_FILE, "a") as pgHbaConf:
pgHbaConf.write("\n")
pgHbaConf.write("local all " + args.postgres_username +
",mapred md5")
pgHbaConf.write("\n")
pgHbaConf.write("host all " + args.postgres_username +
",mapred 0.0.0.0/0 md5")
pgHbaConf.write("\n")
pgHbaConf.write("host all " + args.postgres_username +
",mapred ::/0 md5")
pgHbaConf.write("\n")
command = PG_HBA_RELOAD_CMD.format(PG_HBA_DIR)
retcode, out, err = run_os_command(command)
if not retcode == 0:
print err
sys.exit(retcode)
def simplifyExtent(self):
taxonKey = int(self.taxonKeyToSimplify.get())
print("Simplifying taxon: %s" % taxonKey)
dbConn = getDbConnection(optparse.Values(self.dbPane.getDbOptions()))
dbConn.execute((
"WITH ext(taxon_key, geom) AS (" +
" SELECT e.taxon_key, (st_dump(geom)).geom" +
" FROM distribution.taxon_extent e" +
" WHERE e.taxon_key = %(tk)s" + ")" +
"UPDATE distribution.taxon_extent e" +
" SET geom = (SELECT ST_MULTI(ST_Union(ST_Buffer(ST_SimplifyPreserveTopology(geom, 0.01), 0.25)))"
+ " FROM ext" +
" GROUP BY ext.taxon_key)" +
" WHERE e.taxon_key = %(tk)s") % {"tk": taxonKey})
print("Taxon %s simplified. Please review resulting extent." %
taxonKey)
def test_lint_test_files__errors(self):
options = optparse.Values({'platform': 'test', 'debug_rwt_logging': False})
host = MockHost()
port = host.port_factory.get(options.platform, options=options)
port.expectations_dict = lambda: {'foo': '-- syntax error1', 'bar': '-- syntax error2'}
host.port_factory.get = lambda platform, options=None: port
host.port_factory.all_port_names = lambda platform=None: [port.name()]
logging_stream = StringIO.StringIO()
logger, handler = lint_test_expectations.set_up_logging(logging_stream)
try:
res = lint_test_expectations.lint(host, options)
finally:
lint_test_expectations.tear_down_logging(logger, handler)
self.assertTrue(res)
self.assertIn('foo:1', logging_stream.getvalue())
self.assertIn('bar:1', logging_stream.getvalue())
def test_lint_flag_specific_expectation_errors(self):
options = optparse.Values({'platform': 'test', 'debug_rwt_logging': False})
host = MockHost()
port = host.port_factory.get(options.platform, options=options)
port.expectations_dict = lambda: {'flag-specific': 'does/not/exist', 'noproblem': ''}
host.port_factory.get = lambda platform, options=None: port
host.port_factory.all_port_names = lambda platform=None: [port.name()]
logging_stream = StringIO.StringIO()
logger, handler = lint_test_expectations.set_up_logging(logging_stream)
try:
res = lint_test_expectations.lint(host, options)
finally:
lint_test_expectations.tear_down_logging(logger, handler)
self.assertTrue(res)
self.assertIn('flag-specific:1 Path does not exist. does/not/exist', logging_stream.getvalue())
self.assertNotIn('noproblem', logging_stream.getvalue())
def test_get_run_command_default_and_list_expands(self):
ui, command = self.get_test_ui_and_cmd()
if v2_avail:
buffer = BytesIO()
stream = subunit.StreamResultToBytes(buffer)
stream.status(test_id='returned', test_status='exists')
stream.status(test_id='ids', test_status='exists')
subunit_bytes = buffer.getvalue()
else:
subunit_bytes = _b('returned\nids\n')
ui.proc_outputs = [subunit_bytes]
ui.options = optparse.Values()
ui.options.parallel = True
ui.options.concurrency = 2
self.set_config('[DEFAULT]\ntest_command=foo $IDLIST $LISTOPT\n'
'test_id_list_default=whoo yea\n'
'test_list_option=--list\n')
fixture = self.useFixture(command.get_run_command())
expected_cmd = 'foo returned ids '
self.assertEqual(expected_cmd, fixture.cmd)
def test_import_dir_with_no_tests(self):
# FIXME: Use MockHosts instead.
host = Host()
host.executive = MockExecutive2(exception=ScriptError(
"abort: no repository found in '/Volumes/Source/src/wk/Tools/Scripts/webkitpy/w3c' (.hg not found)!"
))
importer = TestImporter(host, '/w3c', '/blink',
optparse.Values({"overwrite": False}))
importer.source_directory = importer.path_from_webkit_root(
"Tools", "Scripts", "webkitpy", "w3c")
importer.destination_directory = tempfile.mkdtemp(prefix='csswg')
oc = OutputCapture()
oc.capture_output()
try:
importer.do_import()
finally:
oc.restore_output()
shutil.rmtree(importer.destination_directory, ignore_errors=True)
def load_command_line(self, conf_only=False):
'''
Load config from command line switches.
NOTE: Not all config is available on the command line.
'''
# did we already parse cli (i.e. to get conf file)? don't run twice
if self._cli_opts:
self._update_dict(self._cli_opts)
return
parser = optparse.OptionParser()
debug_grp = optparse.OptionGroup(parser, "Debug options")
platf_grp = optparse.OptionGroup(parser, "Platform options")
cli_options = dict(
(k, v) for k, v in DEFAULT_OPTS.items() if ('opt' in v))
for _, o in cli_options.items():
group = o.pop('group', None)
if group == 'debug':
g = debug_grp
elif group == 'platform':
g = platf_grp
else:
g = parser
optnames = o.pop('opt')
g.add_option(*optnames, **o)
parser.add_option_group(debug_grp)
# To be revealed... one day.
# parser.add_option_group(platf_grp)
# pass in optparse.Values() to get only options that were specified
options, args = parser.parse_args(values=optparse.Values())
if len(args) > 0:
parser.error("Unknown arguments: %s" % args)
self._cli_opts = vars(options)
if conf_only and 'conf' in self._cli_opts:
self._update_dict({'conf': self._cli_opts['conf']})
return
self._update_dict(self._cli_opts)
