| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.brooklyn.core.workflow; |
| |
| import java.util.Arrays; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.function.Consumer; |
| import java.util.regex.Pattern; |
| |
| import org.apache.brooklyn.core.workflow.utils.ExpressionParser; |
| import org.apache.brooklyn.core.workflow.utils.ExpressionParserImpl.ParseNode; |
| import org.apache.brooklyn.core.workflow.utils.ExpressionParserImpl.ParseNodeOrValue; |
| import org.apache.brooklyn.util.collections.CollectionMerger; |
| import org.apache.brooklyn.util.collections.MutableList; |
| import org.apache.brooklyn.util.collections.MutableMap; |
| import org.apache.brooklyn.util.guava.Maybe; |
| import org.apache.brooklyn.util.text.QuotedStringTokenizer; |
| import org.apache.brooklyn.util.text.Strings; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| /** |
| * This is the latest version of the SP which uses the EP for input, and the QST for templates, |
| * to keep backwards compatibility but allow better handling for internal double quotes and interpolated expressions with spaces. |
| * It falls back to QST when there are errors to maximize compatibility. |
| * |
| * === |
| * |
| * Accepts a shorthand template, and converts it to a map of values, |
| * e.g. given template "[ ?${type_set} ${sensor.type} ] ${sensor.name} \"=\" ${value}" |
| * and input "integer foo=3", this will return |
| * { sensor: { type: integer, name: foo }, value: 3, type_set: true }. |
| * |
| * Expects space-separated TOKEN where TOKEN is either: |
| * |
| * ${VAR} - to set VAR, which should be of the regex [A-Za-z0-9_-]+(\.[A-Za-z0-9_-]+)*, with dot separation used to set nested maps; |
| * will match a quoted string if supplied, else up to the next literal if the next token is a literal, else the next work. |
| * ${VAR...} - as above, but will collect multiple args if needed (if the next token is a literal matched further on, or if at end of word) |
| * "LITERAL" - to expect a literal expression. this must include the quotation marks and should include spaces if spaces are required. |
| * [ TOKEN ] - to indicate TOKEN is optional, where TOKEN is one of the above sections. parsing is attempted first with it, then without it. |
| * [ ?${VAR} TOKEN ] - as `[ TOKEN ]` but VAR is set true or false depending whether this optional section was matched. |
| * |
| * Would be nice to support A | B (exclusive or) for A or B but not both (where A might contain a literal for disambiguation), |
| * and ( X ) for X required but grouped (for use with | (exclusive or) where one option is required). |
| * Would also be nice to support any order, which could be ( A & B ) to allow A B or B A. |
| * |
| * But for now we've made do without it, with some compromises: |
| * * keywords must follow the order indicated |
| * * exclusive alternatives are disallowed by code subsequently or checked separately (eg Transform) |
| */ |
| public class ShorthandProcessorEpToQst { |
| |
| private static final Logger log = LoggerFactory.getLogger(ShorthandProcessorEpToQst.class); |
| |
| static final boolean TRY_HARDER_FOR_QST_COMPATIBILITY = true; |
| |
| private final String template; |
| boolean finalMatchRaw = false; |
| boolean failOnMismatch = true; |
| |
| public ShorthandProcessorEpToQst(String template) { |
| this.template = template; |
| } |
| |
| public Maybe<Map<String,Object>> process(String input) { |
| return new ShorthandProcessorQstAttempt(this, input).call(); |
| } |
| |
| /** whether the last match should preserve quotes and spaces; default false */ |
| public ShorthandProcessorEpToQst withFinalMatchRaw(boolean finalMatchRaw) { |
| this.finalMatchRaw = finalMatchRaw; |
| return this; |
| } |
| |
| /** whether to fail on mismatched quotes in the input, default true */ |
| public ShorthandProcessorEpToQst withFailOnMismatch(boolean failOnMismatch) { |
| this.failOnMismatch = failOnMismatch; |
| return this; |
| } |
| |
| static class ShorthandProcessorQstAttempt { |
| private final List<String> templateTokens; |
| private final String inputOriginal; |
| private final QuotedStringTokenizer qst0; |
| private final String template; |
| private final ShorthandProcessorEpToQst options; |
| int optionalDepth = 0; |
| int optionalSkippingInput = 0; |
| private String inputRemaining; |
| Map<String, Object> result; |
| Consumer<String> valueUpdater; |
| |
| ShorthandProcessorQstAttempt(ShorthandProcessorEpToQst proc, String input) { |
| this.template = proc.template; |
| this.options = proc; |
| this.qst0 = qst0(template); |
| this.templateTokens = qst0.remainderAsList(); // QST works fine for the template |
| this.inputOriginal = input; |
| } |
| |
| private QuotedStringTokenizer qst0(String x) { |
| return QuotedStringTokenizer.builder().includeQuotes(true).includeDelimiters(false).expectQuotesDelimited(true).failOnOpenQuote(options.failOnMismatch).build(x); |
| } |
| |
| public synchronized Maybe<Map<String,Object>> call() { |
| if (result == null) { |
| result = MutableMap.of(); |
| inputRemaining = inputOriginal; |
| } else { |
| throw new IllegalStateException("Only allowed to use once"); |
| } |
| Maybe<Object> error = doCall(); |
| if (error.isAbsent()) return Maybe.Absent.castAbsent(error); |
| inputRemaining = Strings.trimStart(inputRemaining); |
| if (Strings.isNonBlank(inputRemaining)) { |
| if (valueUpdater!=null) { |
| //QuotedStringTokenizer qstInput = qst(inputRemaining); |
| valueUpdater.accept(getRemainderPossiblyRaw(inputRemaining)); |
| } else { |
| // shouldn't come here |
| return Maybe.absent("Input has trailing characters after template is matched: '" + inputRemaining + "'"); |
| } |
| } |
| return Maybe.of(result); |
| } |
| |
| protected Maybe<Object> doCall() { |
| boolean isEndOfOptional = false; |
| outer: while (true) { |
| if (isEndOfOptional) { |
| if (optionalDepth <= 0) { |
| throw new IllegalStateException("Unexpected optional block closure"); |
| } |
| optionalDepth--; |
| if (optionalSkippingInput>0) { |
| // we were in a block where we skipped something optional because it couldn't be matched; outer parser is now canonical, |
| // and should stop skipping |
| return Maybe.of(true); |
| } |
| isEndOfOptional = false; |
| } |
| |
| if (templateTokens.isEmpty()) { |
| if (Strings.isNonBlank(inputRemaining) && valueUpdater==null) { |
| return Maybe.absent("Input has trailing characters after template is matched: '" + inputRemaining + "'"); |
| } |
| if (optionalDepth>0) |
| return Maybe.absent("Mismatched optional marker in template"); |
| return Maybe.of(true); |
| } |
| String t = templateTokens.remove(0); |
| |
| if (t.startsWith("[")) { |
| t = t.substring(1); |
| if (!t.isEmpty()) { |
| templateTokens.add(0, t); |
| } |
| String optionalPresentVar = null; |
| if (!templateTokens.isEmpty() && templateTokens.get(0).startsWith("?")) { |
| String v = templateTokens.remove(0); |
| if (v.startsWith("?${") && v.endsWith("}")) { |
| optionalPresentVar = v.substring(3, v.length() - 1); |
| } else { |
| throw new IllegalStateException("? after [ should indicate optional presence variable using syntax '?${var}', not '"+v+"'"); |
| } |
| } |
| Maybe<Object> cr; |
| if (optionalSkippingInput<=0) { |
| // make a deep copy so that valueUpdater writes get replayed |
| Map<String, Object> backupResult = (Map) CollectionMerger.builder().deep(true).build().merge(MutableMap.of(), result); |
| Consumer<String> backupValueUpdater = valueUpdater; |
| String backupInputRemaining = inputRemaining; |
| List<String> backupTemplateTokens = MutableList.copyOf(templateTokens); |
| int oldDepth = optionalDepth; |
| int oldSkippingDepth = optionalSkippingInput; |
| |
| optionalDepth++; |
| cr = doCall(); |
| if (cr.isPresent()) { |
| // succeeded |
| if (optionalPresentVar!=null) result.put(optionalPresentVar, true); |
| continue; |
| |
| } else { |
| // restore |
| result = backupResult; |
| valueUpdater = backupValueUpdater; |
| if (optionalPresentVar!=null) result.put(optionalPresentVar, false); |
| inputRemaining = backupInputRemaining; |
| templateTokens.clear(); |
| templateTokens.addAll(backupTemplateTokens); |
| optionalDepth = oldDepth; |
| optionalSkippingInput = oldSkippingDepth; |
| |
| optionalSkippingInput++; |
| optionalDepth++; |
| cr = doCall(); |
| if (cr.isPresent()) { |
| optionalSkippingInput--; |
| continue; |
| } |
| } |
| } else { |
| if (optionalPresentVar!=null) { |
| result.put(optionalPresentVar, false); |
| valueUpdater = null; |
| } |
| optionalDepth++; |
| cr = doCall(); |
| if (cr.isPresent()) { |
| continue; |
| } |
| } |
| return cr; |
| } |
| |
| isEndOfOptional = t.endsWith("]"); |
| |
| if (isEndOfOptional) { |
| t = t.substring(0, t.length() - 1); |
| if (t.isEmpty()) continue; |
| // next loop will process the end of the optionality |
| } |
| |
| if (qst0.isQuoted(t)) { |
| if (optionalSkippingInput>0) continue; |
| |
| String literal = qst0.unwrapIfQuoted(t); |
| do { |
| // ignore leading spaces (since the quoted string tokenizer will have done that anyway); but their _absence_ can be significant for intra-token searching when matching a var |
| inputRemaining = Strings.trimStart(inputRemaining); |
| if (inputRemaining.startsWith(Strings.trimStart(literal))) { |
| // literal found |
| inputRemaining = inputRemaining.substring(Strings.trimStart(literal).length()); |
| continue outer; |
| } |
| if (inputRemaining.isEmpty()) return Maybe.absent("Literal '"+literal+"' expected, when end of input reached"); |
| if (valueUpdater!=null) { |
| if (inputRemaining.isEmpty()) return Maybe.absent("Literal '"+literal+"' expected, when end of input tokens reached"); |
| String value = getNextInputTokenUpToPossibleExpectedLiteral(literal); |
| valueUpdater.accept(value); |
| continue; |
| } |
| return Maybe.absent("Literal '"+literal+"' expected, when encountered '"+inputRemaining+"'"); |
| } while (true); |
| } |
| |
| if (t.startsWith("${") && t.endsWith("}")) { |
| if (optionalSkippingInput>0) continue; |
| |
| t = t.substring(2, t.length()-1); |
| String value; |
| |
| inputRemaining = inputRemaining.trim(); |
| if (inputRemaining.isEmpty()) return Maybe.absent("End of input when looking for variable "+t); |
| |
| if (!templateTokens.stream().filter(x -> !x.equals("]")).findFirst().isPresent()) { |
| // last word (whether optional or not) takes everything |
| value = getRemainderPossiblyRaw(inputRemaining); |
| inputRemaining = ""; |
| |
| } else { |
| value = getNextInputTokenUpToPossibleExpectedLiteral(null); |
| } |
| boolean multiMatch = t.endsWith("..."); |
| if (multiMatch) t = Strings.removeFromEnd(t, "..."); |
| String keys[] = t.split("\\."); |
| final String tt = t; |
| valueUpdater = v2 -> { |
| Map target = result; |
| for (int i=0; i<keys.length; i++) { |
| if (!Pattern.compile("[A-Za-z0-9_-]+").matcher(keys[i]).matches()) { |
| throw new IllegalArgumentException("Invalid variable '"+tt+"'"); |
| } |
| if (i == keys.length - 1) { |
| target.compute(keys[i], (k, v) -> v == null ? v2 : v + " " + v2); |
| } else { |
| // need to make sure we have a map or null |
| target = (Map) target.compute(keys[i], (k, v) -> { |
| if (v == null) return MutableMap.of(); |
| if (v instanceof Map) return v; |
| return Maybe.absent("Cannot process shorthand for " + Arrays.asList(keys) + " because entry '" + k + "' is not a map (" + v + ")"); |
| }); |
| } |
| } |
| }; |
| valueUpdater.accept(value); |
| if (!multiMatch) valueUpdater = null; |
| continue; |
| } |
| |
| // unexpected token |
| return Maybe.absent("Unexpected token in shorthand pattern '"+template+"' at position "+(template.lastIndexOf(t)+1)); |
| } |
| } |
| |
| private String getRemainderPossiblyRawQst(QuotedStringTokenizer qstInput) { |
| String value; |
| value = Strings.join(qstInput.remainderRaw(), ""); |
| if (!options.finalMatchRaw) { |
| return qstInput.unwrapIfQuoted(value); |
| } |
| return value; |
| } |
| |
| private String getRemainderPossiblyRaw(String inputRemaining) { |
| Maybe<String> mp = getRemainderPossiblyRawEp(inputRemaining); |
| |
| if (TRY_HARDER_FOR_QST_COMPATIBILITY || (mp.isAbsent() && !options.failOnMismatch)) { |
| String qstResult = getRemainderPossiblyRawQst(qst0(inputRemaining)); |
| if (mp.isPresent() && !mp.get().equals(qstResult)) { |
| log.debug("Shorthand parsing semantics change for: "+inputOriginal+"\n" + |
| " old qst: "+qstResult+"\n"+ |
| " new exp: "+mp.get()); |
| // to debug |
| // getRemainderPossiblyRawEp(inputRemaining); |
| } |
| if (mp.isAbsent()) { |
| return qstResult; |
| } |
| } |
| |
| return mp.get(); |
| } |
| private Maybe<String> getRemainderPossiblyRawEp(String inputRemaining) { |
| if (options.finalMatchRaw) { |
| return Maybe.of(inputRemaining); |
| } |
| Maybe<List<ParseNodeOrValue>> mp = ShorthandProcessorExprParser.tokenizer().parseEverything(inputRemaining); |
| return mp.map(pnl -> { |
| final boolean UNQUOTE_INDIVIDUAL_WORDS = false; // legacy behaviour |
| |
| if (pnl.size()==1 || UNQUOTE_INDIVIDUAL_WORDS) { |
| return ExpressionParser.getAllUnquoted(pnl); |
| } else { |
| return ExpressionParser.getUnescapedButNotUnquoted(pnl); |
| } |
| }); |
| } |
| |
| private String getNextInputTokenUpToPossibleExpectedLiteralQst(QuotedStringTokenizer qstInput, String nextLiteral) { |
| String value; |
| if (!qstInput.hasMoreTokens()) { |
| return ""; // shouldn't happen |
| } |
| String v = qstInput.nextToken(); |
| if (qstInput.isQuoted(v)) { |
| // input was quoted, eg "\"foo=b\" ..." -- ignore the = in "foo=b" |
| value = qstInput.unwrapIfQuoted(v); |
| inputRemaining = inputRemaining.substring(v.length()); |
| } else { |
| // input not quoted, if next template token is literal, look for it |
| boolean isLiteralExpected; |
| if (nextLiteral==null) { |
| nextLiteral = templateTokens.get(0); |
| if (qstInput.isQuoted(nextLiteral)) { |
| nextLiteral = qstInput.unwrapIfQuoted(nextLiteral); |
| isLiteralExpected = true; |
| } else { |
| isLiteralExpected = false; |
| } |
| } else { |
| isLiteralExpected = true; |
| } |
| if (isLiteralExpected) { |
| int nli = v.indexOf(nextLiteral); |
| if (nli>0) { |
| // literal found in unquoted string, eg "foo=bar" when literal is = |
| value = v.substring(0, nli); |
| inputRemaining = inputRemaining.substring(value.length()); |
| } else { |
| // literal not found |
| value = v; |
| inputRemaining = inputRemaining.substring(value.length()); |
| } |
| } else { |
| // next is not a literal, so the whole token is the value |
| value = v; |
| inputRemaining = inputRemaining.substring(value.length()); |
| } |
| } |
| return value; |
| } |
| |
| private String getNextInputTokenUpToPossibleExpectedLiteral(String nextLiteral) { |
| String oi = inputRemaining; |
| Maybe<String> v1 = getNextInputTokenUpToPossibleExpectedLiteralEp(nextLiteral); |
| |
| if (TRY_HARDER_FOR_QST_COMPATIBILITY || (v1.isAbsent() && !options.failOnMismatch)) { |
| String ni = inputRemaining; |
| |
| inputRemaining = oi; |
| String qstResult = getNextInputTokenUpToPossibleExpectedLiteralQst(qst0(inputRemaining), nextLiteral); |
| if (v1.isPresent() && !v1.get().equals(qstResult)) { |
| log.debug("Shorthand parsing semantics change for literal " + nextLiteral + ": " + inputOriginal + "\n" + |
| " old qst: " + qstResult + "\n" + |
| " new exp: " + v1.get()); |
| |
| // // to debug differences |
| // inputRemaining = oi; |
| //// getNextInputTokenUpToPossibleExpectedLiteralQst(qst0(inputRemaining), nextLiteral); |
| // getNextInputTokenUpToPossibleExpectedLiteralEp(nextLiteral); |
| } |
| if (v1.isAbsent()) { |
| return qstResult; |
| } |
| inputRemaining = ni; |
| } |
| |
| return v1.get(); |
| } |
| |
| private Maybe<String> getNextInputTokenUpToPossibleExpectedLiteralEp(String nextLiteral) { |
| String result = ""; |
| boolean canRepeat = true; |
| |
| Maybe<ParseNode> parseM = ShorthandProcessorExprParser.tokenizer().parse(inputRemaining); |
| while (canRepeat) { |
| String value; |
| if (parseM.isAbsent()) return Maybe.castAbsent(parseM); |
| |
| List<ParseNodeOrValue> tokens = parseM.get().getContents(); |
| ParseNodeOrValue t = tokens.iterator().next(); |
| |
| if (ExpressionParser.isQuotedExpressionNode(t)) { |
| // input was quoted, eg "\"foo=b\" ..." -- ignore the = in "foo=b" |
| value = ExpressionParser.getUnquoted(t); |
| inputRemaining = inputRemaining.substring(t.getSource().length()); |
| |
| } else { |
| // input not quoted, if next template token is literal, look for it |
| boolean isLiteralExpected; |
| if (nextLiteral == null) { |
| String nl = templateTokens.get(0); |
| if (qst0.isQuoted(nl)) { |
| nextLiteral = qst0.unwrapIfQuoted(nl); |
| isLiteralExpected = true; |
| } else { |
| isLiteralExpected = false; |
| } |
| } else { |
| isLiteralExpected = true; |
| } |
| if (isLiteralExpected) { |
| int nli = |
| // previously took next QST token |
| qst0(inputRemaining).nextToken().indexOf(nextLiteral); |
| |
| // // this is simple, slightly greedier; |
| // // slightly too greedy, in that nextLiteral inside quotes further away will match |
| // // and it breaks backwards compatibility |
| // inputRemaining.indexOf(nextLiteral); |
| |
| // // this parse node is probably too short |
| // t.getSource().indexOf(nextLiteral); |
| |
| final boolean ALLOW_NOTHING_BEFORE_LITERAL = false; |
| if ((nli == 0 && ALLOW_NOTHING_BEFORE_LITERAL) || nli > 0) { |
| // literal found in unquoted string, eg "foo=bar" when literal is = |
| if (!qst0(inputRemaining).nextToken().startsWith(inputRemaining.substring(0, nli))) { |
| String v = qst0(inputRemaining).nextToken(); |
| } |
| value = inputRemaining.substring(0, nli); |
| inputRemaining = inputRemaining.substring(nli); |
| canRepeat = false; |
| |
| } else { |
| // literal not found |
| value = t.getSource(); // since we know it isn't quoted |
| inputRemaining = inputRemaining.substring(value.length()); |
| } |
| } else { |
| // next is not a literal, so the whole token is the value - not unquoted |
| value = t.getSource(); |
| inputRemaining = inputRemaining.substring(value.length()); |
| } |
| } |
| result += value; |
| |
| canRepeat &= !inputRemaining.isEmpty(); |
| if (canRepeat) { |
| parseM = ShorthandProcessorExprParser.tokenizer().parse(inputRemaining); |
| if (parseM.isAbsent()) canRepeat = false; |
| else { |
| if (ExpressionParser.startsWithWhitespace(parseM.get())) canRepeat = false; |
| // otherwise, to act like QST, we treat non-whitespace-separated things all as one token |
| } |
| } |
| } |
| |
| return Maybe.of(result); |
| } |
| |
| } |
| |
| } |
