def queryString(
self,
name,
note=None,
validValues=None,
caseSensitive=True,
hidden=False,
prompt=False,
default=None,
):
self.logger.debug('query %s', name)
if default is not None:
default = common.toStr(default)
if validValues is not None:
validValues = [common.toStr(v) for v in validValues]
note = self._queryStringNote(
name=name,
note=note,
validValues=validValues,
default=default,
)
if not caseSensitive and validValues is not None:
validValues = [v.lower() for v in validValues]
accepted = False
if (
self.environment[constants.DialogEnv.AUTO_ACCEPT_DEFAULT] and
default is not None
):
tempval = default if caseSensitive else default.lower()
if (
validValues is None or
tempval in validValues
):
self.dialog.note(text=note, prompt=False)
value = tempval
accepted = True
while not accepted:
self.dialog.note(text=note, prompt=prompt)
value = self._readline(hidden=hidden)
if not value and default is not None:
value = default
if not caseSensitive:
value = value.lower()
if validValues is not None and value not in validValues:
self.logger.error(_('Invalid value'))
elif not value and value != default:
self.logger.error(_('Please specify value'))
else:
accepted = True
return value
def note(self, text=None, prompt=False):
def printline(line, newline=True):
PREFIX = ' '
self._write(
text='%s%s%s' % (
PREFIX,
' ' + line if line else '',
'\n' if newline else '',
),
flush=False,
)
if isinstance(text, list) or isinstance(text, tuple):
for i in text:
self.note(text=i)
return
if text is None:
text = '\n'
text = common.toStr(text)
lines = text.splitlines()
if len(lines) > 0:
for line in lines[:-1]:
printline(line)
printline(lines[-1], newline=not prompt)
self._flush()
def note(self, text=None, prompt=False):
def printline(line, newline=True):
PREFIX = ' '
self._write(
text='%s%s%s' % (
PREFIX,
' ' + line if line else '',
'\n' if newline else '',
),
flush=False,
)
if isinstance(text, list) or isinstance(text, tuple):
for i in text:
self.note(text=i)
return
if text is None:
text = '\n'
text = common.toStr(text)
lines = text.splitlines()
if len(lines) > 0:
for line in lines[:-1]:
printline(line)
printline(lines[-1], newline=not prompt)
self._flush()
def queryString(
self,
name,
note=None,
validValues=None,
caseSensitive=True,
hidden=False,
prompt=False,
default=False,
):
if default is not None:
default = common.toStr(default)
if validValues is not None:
validValues = [common.toStr(v) for v in validValues]
note = self._queryStringNote(
name=name,
note=note,
validValues=validValues,
default=default,
)
if not caseSensitive and validValues is not None:
validValues = [v.lower() for v in validValues]
self._write(
text='%s%s %s\n' % (
dialogcons.DialogMachineConst.REQUEST_PREFIX,
dialogcons.DialogMachineConst.QUERY_STRING,
name,
)
)
self.dialog.note(text=note, prompt=prompt)
value = self._readline()
if not value and default is not None:
value = default
if not caseSensitive:
value = value.lower()
if (
(validValues is not None and value not in validValues) or
(not value and value != default)
):
raise RuntimeError(
_("Invalid value provided to '{name}'").format(
name=name
)
)
return value
def execute(self):
try:
self.context.loadPlugins()
except Exception as e:
util.raiseExceptionInformation(info=(
PluginLoadException,
PluginLoadException(common.toStr(e)),
sys.exc_info()[2],
))
self.context.buildSequence()
self.context.runSequence()
def queryString(
self,
name,
note=None,
validValues=None,
caseSensitive=True,
hidden=False,
prompt=False,
default=None,
):
self.logger.debug('query %s', name)
if default is not None:
default = common.toStr(default)
if validValues is not None:
validValues = [common.toStr(v) for v in validValues]
note = self._queryStringNote(
name=name,
note=note,
validValues=validValues,
default=default,
)
if not caseSensitive and validValues is not None:
validValues = [v.lower() for v in validValues]
accepted = False
while not accepted:
self.dialog.note(text=note, prompt=prompt)
value = self._readline(hidden=hidden)
if not value and default is not None:
value = default
if not caseSensitive:
value = value.lower()
if validValues is not None and value not in validValues:
self.logger.error(_('Invalid value'))
elif not value and value != default:
self.logger.error(_('Please specify value'))
else:
accepted = True
return value
def queryString(
self,
name,
note=None,
validValues=None,
caseSensitive=True,
hidden=False,
prompt=False,
default=None,
):
self.logger.debug('query %s', name)
if default is not None:
default = common.toStr(default)
if validValues is not None:
validValues = [common.toStr(v) for v in validValues]
note = self._queryStringNote(
name=name,
note=note,
validValues=validValues,
default=default,
)
if not caseSensitive and validValues is not None:
validValues = [v.lower() for v in validValues]
accepted = False
while not accepted:
self.dialog.note(text=note, prompt=prompt)
value = self._readline(hidden=hidden)
if not value and default is not None:
value = default
if not caseSensitive:
value = value.lower()
if validValues is not None and value not in validValues:
self.logger.error(_('Invalid value'))
elif not value and value != default:
self.logger.error(_('Please specify value'))
else:
accepted = True
return value
def execute(self):
try:
self.context.loadPlugins()
except Exception as e:
util.raiseExceptionInformation(
info=(
PluginLoadException,
PluginLoadException(common.toStr(e)),
sys.exc_info()[2],
)
)
self.context.buildSequence()
self.context.runSequence()
def note(self, text=None, prompt=False):
PREFIX = '{p}{p}{p}'.format(
p=dialogcons.DialogMachineConst.NOTE_PREFIX)
if isinstance(text, list) or isinstance(text, tuple):
for i in text:
self.note(text=i)
return
if text is None:
text = '\n'
text = common.toStr(text)
for line in text.splitlines():
self._write(
text='%s%s\n' % (PREFIX, ' ' + line if line else ''),
flush=False,
)
self._flush()
def note(self, text=None, prompt=False):
PREFIX = '{p}{p}{p}'.format(
p=dialogcons.DialogMachineConst.NOTE_PREFIX
)
if isinstance(text, list) or isinstance(text, tuple):
for i in text:
self.note(text=i)
return
if text is None:
text = '\n'
text = common.toStr(text)
for line in text.splitlines():
self._write(
text='%s%s\n' % (
PREFIX,
' ' + line if line else ''
),
flush=False,
)
self._flush()
def queryString(
self,
name,
note=None,
validValues=None,
caseSensitive=True,
hidden=False,
prompt=False,
default=None,
):
if default is not None:
default = common.toStr(default)
if validValues is not None:
validValues = [common.toStr(v) for v in validValues]
note = self._queryStringNote(
name=name,
note=note,
validValues=validValues,
default=default,
)
occurrence = self._question_occurrences.get(name, 1)
envkey = '{prefix}{occurrence}/{name}'.format(
prefix=constants.CoreEnv.QUESTION_PREFIX,
occurrence=str(occurrence),
name=name,
)
self._question_occurrences[name] = occurrence + 1
if envkey in self.environment:
# Answer provided in answerfile. No need to prompt or
# anything. TODO Consider formalizing this in the machine
# dialog protocol so that the client knows that we were
# supposed to ask something but already got an answer.
# For now just output this as a note, just like the
# human dialect.
answer = self.environment[envkey]
self.dialog.note(text=note, prompt=False)
self.dialog.note(
_('provided answer: {answer}').format(
answer=_('(hidden)') if hidden else answer, ))
value = answer
else:
self._writeQueryStart(name)
self.dialog.note(text=note, prompt=prompt)
if default:
self._write(text='%s %s\n' % (
_qep(dialogcons.DialogMachineConst.QUERY_DEFAULT_VALUE),
default,
))
if validValues:
self._write(text='%s %s\n' % (
_qep(dialogcons.DialogMachineConst.QUERY_VALID_VALUES),
'|'.join([
x.replace('\\', '\\\\').replace('|', '\|')
for x in validValues
]),
))
self._write(
text='%s %s\n' %
(_qep(dialogcons.DialogMachineConst.QUERY_HIDDEN),
(dialogcons.DialogMachineConst.QUERY_HIDDEN_TRUE if hidden
else dialogcons.DialogMachineConst.QUERY_HIDDEN_FALSE)))
self._write(text='%s%s %s\n' % (
dialogcons.DialogMachineConst.REQUEST_PREFIX,
dialogcons.DialogMachineConst.QUERY_STRING,
name,
))
self._writeQueryEnd(name)
if not caseSensitive and validValues is not None:
validValues = [v.lower() for v in validValues]
value = self._readline(hidden)
if not value and default is not None:
value = default
if not caseSensitive:
value = value.lower()
if ((validValues is not None and value not in validValues)
or (not value and value != default)):
raise RuntimeError(
_("Invalid value provided to '{name}'").format(name=name))
self.environment[envkey] = value
if hidden:
self.environment[constants.CoreEnv.LOG_FILTER].append(value)
return value
def queryString(
self,
name,
note=None,
validValues=None,
caseSensitive=True,
hidden=False,
prompt=False,
default=None,
):
if default is not None:
default = common.toStr(default)
if validValues is not None:
validValues = [common.toStr(v) for v in validValues]
note = self._queryStringNote(
name=name,
note=note,
validValues=validValues,
default=default,
)
self._writeQueryStart(name)
self.dialog.note(text=note, prompt=prompt)
if default:
self._write(text='%s%s %s\n' % (
dialogcons.DialogMachineConst.QUERY_EXTRA_PREFIX,
dialogcons.DialogMachineConst.QUERY_DEFAULT_VALUE,
default,
))
if validValues:
self._write(text='%s%s %s\n' % (
dialogcons.DialogMachineConst.QUERY_EXTRA_PREFIX,
dialogcons.DialogMachineConst.QUERY_VALID_VALUES,
'|'.join([
x.replace('\\', '\\\\').replace('|', '\|')
for x in validValues
]),
))
self._write(text='%s%s %s\n' %
(dialogcons.DialogMachineConst.QUERY_EXTRA_PREFIX,
dialogcons.DialogMachineConst.QUERY_HIDDEN,
(dialogcons.DialogMachineConst.QUERY_HIDDEN_TRUE if hidden
else dialogcons.DialogMachineConst.QUERY_HIDDEN_FALSE)))
self._write(text='%s%s %s\n' % (
dialogcons.DialogMachineConst.REQUEST_PREFIX,
dialogcons.DialogMachineConst.QUERY_STRING,
name,
))
self._writeQueryEnd(name)
if not caseSensitive and validValues is not None:
validValues = [v.lower() for v in validValues]
value = self._readline(hidden)
if not value and default is not None:
value = default
if not caseSensitive:
value = value.lower()
if ((validValues is not None and value not in validValues)
or (not value and value != default)):
raise RuntimeError(
_("Invalid value provided to '{name}'").format(name=name))
return value
def queryString(
self,
name,
note=None,
validValues=None,
caseSensitive=True,
hidden=False,
prompt=False,
default=None,
):
if default is not None:
default = common.toStr(default)
if validValues is not None:
validValues = [common.toStr(v) for v in validValues]
note = self._queryStringNote(
name=name,
note=note,
validValues=validValues,
default=default,
)
self._writeQueryStart(name)
self.dialog.note(text=note, prompt=prompt)
if default:
self._write(
text='%s%s %s\n' % (
dialogcons.DialogMachineConst.QUERY_EXTRA_PREFIX,
dialogcons.DialogMachineConst.QUERY_DEFAULT_VALUE,
default,
)
)
if validValues:
self._write(
text='%s%s %s\n' % (
dialogcons.DialogMachineConst.QUERY_EXTRA_PREFIX,
dialogcons.DialogMachineConst.QUERY_VALID_VALUES,
'|'.join(
[
x.replace('\\', '\\\\').replace('|', '\|')
for x in validValues
]
),
)
)
self._write(
text='%s%s %s\n' % (
dialogcons.DialogMachineConst.QUERY_EXTRA_PREFIX,
dialogcons.DialogMachineConst.QUERY_HIDDEN,
(
dialogcons.DialogMachineConst.QUERY_HIDDEN_TRUE if hidden
else dialogcons.DialogMachineConst.QUERY_HIDDEN_FALSE
)
)
)
self._write(
text='%s%s %s\n' % (
dialogcons.DialogMachineConst.REQUEST_PREFIX,
dialogcons.DialogMachineConst.QUERY_STRING,
name,
)
)
self._writeQueryEnd(name)
if not caseSensitive and validValues is not None:
validValues = [v.lower() for v in validValues]
value = self._readline(hidden)
if not value and default is not None:
value = default
if not caseSensitive:
value = value.lower()
if (
(validValues is not None and value not in validValues) or
(not value and value != default)
):
raise RuntimeError(
_("Invalid value provided to '{name}'").format(
name=name
)
)
return value
def _setupLogging(self):
self.environment[constants.CoreEnv.LOG_FILE_HANDLE] = None
self.environment[constants.CoreEnv.LOG_FILTER] = self._MyLoggerFilter()
self.environment[constants.CoreEnv.LOG_FILTER_RE] = []
self.environment[
constants.CoreEnv.LOG_FILTER_RE
].append(
re.compile(
flags=re.VERBOSE | re.DOTALL,
pattern=r"""
BEGIN\ PRIVATE\ KEY
(?P<filter>.*)
END\ PRIVATE\ KEY
""",
)
)
self.environment.setdefault(
constants.CoreEnv.LOG_FILE_NAME_PREFIX,
constants.Defaults.LOG_FILE_PREFIX
)
#
# Allow system environment to override both
# the log dir and the log file
#
self.environment[constants.CoreEnv.LOG_DIR] = os.environ.get(
constants.SystemEnvironment.LOG_DIR,
self.environment.get(
constants.CoreEnv.LOG_DIR,
tempfile.gettempdir(),
),
)
logFileName = self.environment[
constants.CoreEnv.LOG_FILE_NAME
] = os.environ.get(
constants.SystemEnvironment.LOG_FILE,
self.environment.get(
constants.CoreEnv.LOG_FILE_NAME,
os.path.join(
self.environment[constants.CoreEnv.LOG_DIR],
"%s-%s-%s.log" % (
self.environment[
constants.CoreEnv.LOG_FILE_NAME_PREFIX
],
time.strftime("%Y%m%d%H%M%S"),
''.join(
[
random.choice(
string.ascii_lowercase +
string.digits
) for i in range(6)
]
)
)
)
),
)
logFileName = self.resolveFile(logFileName)
# put in our environment
# so when re-exec we use same log
os.environ[constants.SystemEnvironment.LOG_FILE] = logFileName
try:
self.environment[constants.CoreEnv.LOG_FILE_HANDLE] = open(
logFileName,
mode='a',
buffering=1,
)
except IOError as e:
self._logerror = common.toStr(e)
self.environment[constants.CoreEnv.LOG_FILE_HANDLE] = open(
os.devnull,
mode='a',
buffering=1,
)
self._handler = logging.StreamHandler(
self.environment[constants.CoreEnv.LOG_FILE_HANDLE]
)
self._handler.setLevel(logging.DEBUG)
self._handler.setFormatter(
self._MyFormatter(
fmt=(
'%(asctime)s %(levelname)s %(name)s '
'%(module)s.%(funcName)s:%(lineno)d '
'%(message)s'
),
environment=self.environment,
)
)
l = logging.getLogger("otopi")
l.addHandler(self._handler)
self._filtered_keys_at_setup = self.environment[
constants.CoreEnv.LOG_FILTER_KEYS
][:]
def queryString(
self,
name,
note=None,
validValues=None,
caseSensitive=True,
hidden=False,
prompt=False,
default=None,
):
if default is not None:
default = common.toStr(default)
if validValues is not None:
validValues = [common.toStr(v) for v in validValues]
note = self._queryStringNote(
name=name,
note=note,
validValues=validValues,
default=default,
)
occurrence = self._question_occurrences.get(name, 1)
envkey = '{prefix}{occurrence}/{name}'.format(
prefix=constants.CoreEnv.QUESTION_PREFIX,
occurrence=str(occurrence),
name=name,
)
self._question_occurrences[name] = occurrence+1
if envkey in self.environment:
# Answer provided in answerfile. No need to prompt or
# anything. TODO Consider formalizing this in the machine
# dialog protocol so that the client knows that we were
# supposed to ask something but already got an answer.
# For now just output this as a note, just like the
# human dialect.
answer = self.environment[envkey]
self.dialog.note(text=note, prompt=False)
self.dialog.note(
_(
'provided answer: {answer}'
).format(
answer=_('(hidden)') if hidden else answer,
)
)
value = answer
else:
self._writeQueryStart(name)
self.dialog.note(text=note, prompt=prompt)
if default:
self._write(
text='%s %s\n' % (
_qep(
dialogcons.DialogMachineConst.QUERY_DEFAULT_VALUE
),
default,
)
)
if validValues:
self._write(
text='%s %s\n' % (
_qep(dialogcons.DialogMachineConst.QUERY_VALID_VALUES),
'|'.join(
[
x.replace('\\', '\\\\').replace('|', '\|')
for x in validValues
]
),
)
)
self._write(
text='%s %s\n' % (
_qep(dialogcons.DialogMachineConst.QUERY_HIDDEN),
(
dialogcons.DialogMachineConst.QUERY_HIDDEN_TRUE
if hidden
else dialogcons.DialogMachineConst.QUERY_HIDDEN_FALSE
)
)
)
self._write(
text='%s%s %s\n' % (
dialogcons.DialogMachineConst.REQUEST_PREFIX,
dialogcons.DialogMachineConst.QUERY_STRING,
name,
)
)
self._writeQueryEnd(name)
if not caseSensitive and validValues is not None:
validValues = [v.lower() for v in validValues]
value = self._readline(hidden)
if not value and default is not None:
value = default
if not caseSensitive:
value = value.lower()
if (
(validValues is not None and value not in validValues) or
(not value and value != default)
):
raise RuntimeError(
_("Invalid value provided to '{name}'").format(
name=name
)
)
self.environment[envkey] = value
if hidden:
self.environment[constants.CoreEnv.LOG_FILTER].append(value)
return value
def queryString(
self,
name,
note=None,
validValues=None,
caseSensitive=True,
hidden=False,
prompt=False,
default=None,
):
self.logger.debug('query %s', name)
if default is not None:
default = common.toStr(default)
if validValues is not None:
validValues = [common.toStr(v) for v in validValues]
note = self._queryStringNote(
name=name,
note=note,
validValues=validValues,
default=default,
)
if not caseSensitive and validValues is not None:
validValues = [v.lower() for v in validValues]
accepted = False
if (self.environment[constants.DialogEnv.AUTO_ACCEPT_DEFAULT]
and default is not None):
tempval = default if caseSensitive else default.lower()
if (validValues is None or tempval in validValues):
self.dialog.note(text=note, prompt=False)
value = tempval
accepted = True
occurrence = self._question_occurrences.get(name, 1)
envkey = '{prefix}{occurrence}/{name}'.format(
prefix=constants.CoreEnv.QUESTION_PREFIX,
occurrence=str(occurrence),
name=name,
)
self._question_occurrences[name] = occurrence + 1
if envkey in self.environment:
answer = self.environment[envkey]
self.dialog.note(text=note, prompt=False)
self.dialog.note(
_('provided answer: {answer}').format(
answer=_('(hidden)') if hidden else answer, ))
value = answer
accepted = True
while not accepted:
self.dialog.note(text=note, prompt=prompt)
value = self._readline(hidden=hidden)
if not value and default is not None:
value = default
if not caseSensitive:
value = value.lower()
if validValues is not None and value not in validValues:
self.logger.error(_('Invalid value'))
elif not value and value != default:
self.logger.error(_('Please specify value'))
else:
accepted = True
self.environment[envkey] = value
if hidden:
self.environment[constants.CoreEnv.LOG_FILTER].append(value)
return value
def _setupLogging(self):
self.environment[constants.CoreEnv.LOG_FILE_HANDLE] = None
self.environment[constants.CoreEnv.LOG_FILTER] = self._MyLoggerFilter()
self.environment[constants.CoreEnv.LOG_FILTER_KEYS] = []
self.environment.setdefault(constants.CoreEnv.LOG_FILE_NAME_PREFIX,
constants.Defaults.LOG_FILE_PREFIX)
#
# Allow system environment to override both
# the log dir and the log file
#
self.environment[constants.CoreEnv.LOG_DIR] = os.environ.get(
constants.SystemEnvironment.LOG_DIR,
self.environment.get(
constants.CoreEnv.LOG_DIR,
tempfile.gettempdir(),
),
)
logFileName = self.environment[
constants.CoreEnv.LOG_FILE_NAME] = os.environ.get(
constants.SystemEnvironment.LOG_FILE,
self.environment.get(
constants.CoreEnv.LOG_FILE_NAME,
os.path.join(
self.environment[constants.CoreEnv.LOG_DIR],
"%s-%s-%s.log" %
(self.environment[
constants.CoreEnv.LOG_FILE_NAME_PREFIX],
time.strftime("%Y%m%d%H%M%S"), ''.join([
random.choice(string.ascii_lowercase +
string.digits) for i in range(6)
])))),
)
logFileName = self.resolveFile(logFileName)
# put in our environment
# so when re-exec we use same log
os.environ[constants.SystemEnvironment.LOG_FILE] = logFileName
try:
self.environment[constants.CoreEnv.LOG_FILE_HANDLE] = open(
logFileName,
mode='a',
buffering=1,
)
except IOError as e:
self._logerror = common.toStr(e)
self.environment[constants.CoreEnv.LOG_FILE_HANDLE] = open(
os.devnull,
mode='a',
buffering=1,
)
self._handler = logging.StreamHandler(
self.environment[constants.CoreEnv.LOG_FILE_HANDLE])
self._handler.setLevel(logging.DEBUG)
self._handler.setFormatter(
self._MyFormatter(
fmt=('%(asctime)s %(levelname)s %(name)s '
'%(module)s.%(funcName)s:%(lineno)d '
'%(message)s'),
datefmt='%Y-%m-%d %H:%M:%S',
environment=self.environment,
))
l = logging.getLogger("otopi")
l.addHandler(self._handler)
def queryString(
self,
name,
note=None,
validValues=None,
caseSensitive=True,
hidden=False,
prompt=False,
default=None,
):
self.logger.debug('query %s', name)
if default is not None:
default = common.toStr(default)
if validValues is not None:
validValues = [common.toStr(v) for v in validValues]
note = self._queryStringNote(
name=name,
note=note,
validValues=validValues,
default=default,
)
if not caseSensitive and validValues is not None:
validValues = [v.lower() for v in validValues]
accepted = False
if (
self.environment[constants.DialogEnv.AUTO_ACCEPT_DEFAULT] and
default is not None
):
tempval = default if caseSensitive else default.lower()
if (
validValues is None or
tempval in validValues
):
self.dialog.note(text=note, prompt=False)
value = tempval
accepted = True
occurrence = self._question_occurrences.get(name, 1)
envkey = '{prefix}{occurrence}/{name}'.format(
prefix=constants.CoreEnv.QUESTION_PREFIX,
occurrence=str(occurrence),
name=name,
)
self._question_occurrences[name] = occurrence+1
if envkey in self.environment:
answer = self.environment[envkey]
self.dialog.note(text=note, prompt=False)
self.dialog.note(
_(
'provided answer: {answer}'
).format(
answer=_('(hidden)') if hidden else answer,
)
)
value = answer
accepted = True
while not accepted:
self.dialog.note(text=note, prompt=prompt)
value = self._readline(hidden=hidden)
if not value and default is not None:
value = default
if not caseSensitive:
value = value.lower()
if validValues is not None and value not in validValues:
self.logger.error(_('Invalid value'))
elif not value and value != default:
self.logger.error(_('Please specify value'))
else:
accepted = True
self.environment[envkey] = value
if hidden:
self.environment[constants.CoreEnv.LOG_FILTER].append(value)
return value
