Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed 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 com.facebook.presto.execution;
 
 
 
 import java.io.File;
 import java.util.List;
 import java.util.Map;
 
 import static com.facebook.presto.SystemSessionProperties.BIG_QUERY;
 import static com.facebook.presto.execution.QueuedExecution.createQueuedExecution;
 import static com.facebook.presto.spi.StandardErrorCode.USER_ERROR;
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 import static java.lang.String.format;
 
 public class SqlQueryQueueManager
         implements QueryQueueManager
 {
     private final ConcurrentMap<QueueKeyQueryQueuequeryQueues = new ConcurrentHashMap<>();
     private final List<QueryQueueRulerules;
     private final MBeanExporter mbeanExporter;
 
     @Inject
     public SqlQueryQueueManager(QueryManagerConfig configObjectMapper mapperMBeanExporter mbeanExporter)
     {
         checkNotNull(config"config is null");
         this. = checkNotNull(mbeanExporter"mbeanExporter is null");
 
         ImmutableList.Builder<QueryQueueRulerules = ImmutableList.builder();
         if (config.getQueueConfigFile() == null) {
             QueryQueueDefinition global = new QueryQueueDefinition("global"config.getMaxConcurrentQueries(), config.getMaxQueuedQueries());
             QueryQueueDefinition big = new QueryQueueDefinition("big"config.getMaxConcurrentBigQueries(), config.getMaxQueuedBigQueries());
             rules.add(new QueryQueueRule(nullnull, ImmutableMap.of(, Pattern.compile("true".)), ImmutableList.of(big)));
             rules.add(new QueryQueueRule(nullnull, ImmutableMap.of(), ImmutableList.of(global)));
         }
         else {
             File file = new File(config.getQueueConfigFile());
             ManagerSpec managerSpec;
             try {
                 managerSpec = mapper.readValue(fileManagerSpec.class);
             }
             catch (IOException e) {
                 throw Throwables.propagate(e);
             }
             Map<StringQueryQueueDefinitiondefinitions = new HashMap<>();
             for (Map.Entry<StringQueueSpecqueue : managerSpec.getQueues().entrySet()) {
                 definitions.put(queue.getKey(), new QueryQueueDefinition(queue.getKey(), queue.getValue().getMaxConcurrent(), queue.getValue().getMaxQueued()));
             }
 
             for (RuleSpec rule : managerSpec.getRules()) {
                 rules.add(QueryQueueRule.createRule(rule.getUserRegex(), rule.getSourceRegex(), rule.getSessionPropertyRegexes(), rule.getQueues(), definitions));
             }
         }
         this. = rules.build();
         checkIsDAG(this.);
     }
    private static void checkIsDAG(List<QueryQueueRulerules)
    {
        DirectedPseudograph<StringDefaultEdgegraph = new DirectedPseudograph<>(DefaultEdge.class);
        for (QueryQueueRule rule : rules) {
            String lastQueueName = null;
            for (QueryQueueDefinition queue : rule.getQueues()) {
                String currentQueueName = queue.getTemplate();
                graph.addVertex(currentQueueName);
                if (lastQueueName != null) {
                    graph.addEdge(lastQueueNamecurrentQueueName);
                }
                lastQueueName = currentQueueName;
            }
        }
        List<StringshortestCycle = shortestCycle(graph);
        if (shortestCycle != null) {
            String s = Joiner.on(", ").join(shortestCycle);
            throw new IllegalArgumentException(format("Queues must not contain a cycle. The shortest cycle found is [%s]"s));
        }
    }
    private static List<StringshortestCycle(DirectedGraph<StringDefaultEdgegraph)
    {
        FloydWarshallShortestPaths<StringDefaultEdgefloyd = new FloydWarshallShortestPaths<>(graph);
        int minDistance = .;
        String minSource = null;
        String minDestination = null;
        for (DefaultEdge edge : graph.edgeSet()) {
            String src = graph.getEdgeSource(edge);
            String dst = graph.getEdgeTarget(edge);
            int dist = (int) Math.round(floyd.shortestDistance(dstsrc)); // from dst to src
            if (dist < 0) {
                continue;
            }
            if (dist < minDistance) {
                minDistance = dist;
                minSource = src;
                minDestination = dst;
            }
        }
        if (minSource == null) {
            return null;
        }
        GraphPath<StringDefaultEdgeshortestPath = floyd.getShortestPath(minDestinationminSource);
        List<StringpathVertexList = Graphs.getPathVertexList(shortestPath);
        // note: pathVertexList will be [a, a] instead of [a] when the shortest path is a loop edge
        if (!Objects.equals(shortestPath.getStartVertex(), shortestPath.getEndVertex())) {
            pathVertexList.add(pathVertexList.get(0));
        }
        return pathVertexList;
    }
    @Override
    public boolean submit(QueryExecution queryExecutionExecutor executorSqlQueryManagerStats stats)
    {
        List<QueryQueuequeues = selectQueues(queryExecution.getQueryInfo().getSession(), executor);
        for (QueryQueue queue : queues) {
            if (!queue.reserve(queryExecution)) {
                // Reject query if we couldn't acquire a permit to enter the queue.
                // The permits will be released when this query fails.
                return false;
            }
        }
        return queues.get(0).enqueue(createQueuedExecution(queryExecutionqueues.subList(1, queues.size()), executorstats));
    }
    // Queues returned have already been created and added queryQueues
    private List<QueryQueueselectQueues(Session sessionExecutor executor)
    {
        for (QueryQueueRule rule : ) {
            List<QueryQueueDefinitiondefinitions = rule.match(session);
            if (definitions != null) {
                return getOrCreateQueues(sessionexecutordefinitions);
            }
        }
        throw new PrestoException("Query did not match any queuing rule");
    }
    private List<QueryQueuegetOrCreateQueues(Session sessionExecutor executorList<QueryQueueDefinitiondefinitions)
    {
        ImmutableList.Builder<QueryQueuequeues = ImmutableList.builder();
        for (QueryQueueDefinition definition : definitions) {
            String expandedName = definition.getExpandedTemplate(session);
            QueueKey key = new QueueKey(definitionexpandedName);
            if (!.containsKey(key)) {
                QueryQueue queue = new QueryQueue(executordefinition.getMaxQueued(), definition.getMaxConcurrent());
                if (.putIfAbsent(keyqueue) == null) {
                    // Export the mbean, after checking for races
                    String objectName = ObjectNames.builder(QueryQueue.classdefinition.getTemplate()).withProperty("expansion"expandedName).build();
                    .export(objectNamequeue);
                }
            }
            queues.add(.get(key));
        }
        return queues.build();
    }
    @PreDestroy
    public void destroy()
    {
        for (QueueKey key : .keySet()) {
            String objectName = ObjectNames.builder(QueryQueue.classkey.getQueue().getTemplate()).withProperty("expansion"key.getName()).build();
            .unexport(objectName);
        }
    }
    private static class QueueKey
    {
        private final QueryQueueDefinition queue;
        private final String name;
        private QueueKey(QueryQueueDefinition queueString name)
        {
            this. = checkNotNull(queue"queue is null");
            this. = checkNotNull(name"name is null");
        }
        public QueryQueueDefinition getQueue()
        {
            return ;
        }
        public String getName()
        {
            return ;
        }
        @Override
        public boolean equals(Object other)
        {
            if (this == other) {
                return true;
            }
            if (other == null || getClass() != other.getClass()) {
                return false;
            }
            QueueKey queueKey = (QueueKeyother;
            return Objects.equals(queueKey.name) && Objects.equals(.getTemplate(), queueKey.queue.getTemplate());
        }
        @Override
        public int hashCode()
        {
            return Objects.hash(.getTemplate(), );
        }
    }
    public static class ManagerSpec
    {
        private final Map<StringQueueSpecqueues;
        private final List<RuleSpecrules;
        @JsonCreator
        public ManagerSpec(
                @JsonProperty("queues"Map<StringQueueSpecqueues,
                @JsonProperty("rules"List<RuleSpecrules)
        {
            this. = ImmutableMap.copyOf(checkNotNull(queues"queues is null"));
            this. = ImmutableList.copyOf(checkNotNull(rules"rules is null"));
        }
        public Map<StringQueueSpecgetQueues()
        {
            return ;
        }
        public List<RuleSpecgetRules()
        {
            return ;
        }
    }
    public static class QueueSpec
    {
        private final int maxQueued;
        private final int maxConcurrent;
        @JsonCreator
        public QueueSpec(
                @JsonProperty("maxQueued"int maxQueued,
                @JsonProperty("maxConcurrent"int maxConcurrent)
        {
            this. = maxQueued;
            this. = maxConcurrent;
        }
        public int getMaxQueued()
        {
            return ;
        }
        public int getMaxConcurrent()
        {
            return ;
        }
    }
    public static class RuleSpec
    {
        @Nullable
        private final Pattern userRegex;
        @Nullable
        private final Pattern sourceRegex;
        private final Map<StringPatternsessionPropertyRegexes = new HashMap<>();
        private final List<Stringqueues;
        @JsonCreator
        public RuleSpec(
                @JsonProperty("user") @Nullable Pattern userRegex,
                @JsonProperty("source") @Nullable Pattern sourceRegex,
                @JsonProperty("queues"List<Stringqueues)
        {
            this. = userRegex;
            this. = sourceRegex;
            this. = ImmutableList.copyOf(queues);
        }
        @JsonAnySetter
        public void setSessionProperty(String propertyPattern value)
        {
            checkArgument(property.startsWith("session."), "Unrecognized property: %s"property);
            .put(property.substring("session.".length(), property.length()), value);
        }
        @Nullable
        public Pattern getUserRegex()
        {
            return ;
        }
        @Nullable
        public Pattern getSourceRegex()
        {
            return ;
        }
        public Map<StringPatterngetSessionPropertyRegexes()
        {
            return ImmutableMap.copyOf();
        }
        public List<StringgetQueues()
        {
            return ;
        }
    }
New to GrepCode? Check out our FAQ X