Line data    Source code

       1             : // Copyright (C) 2011 The Android Open Source Project
       2             : //
       3             : // Licensed under the Apache License, Version 2.0 (the "License");
       4             : // you may not use this file except in compliance with the License.
       5             : // You may obtain a copy of the License at
       6             : //
       7             : // http://www.apache.org/licenses/LICENSE-2.0
       8             : //
       9             : // Unless required by applicable law or agreed to in writing, software
      10             : // distributed under the License is distributed on an "AS IS" BASIS,
      11             : // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      12             : // See the License for the specific language governing permissions and
      13             : // limitations under the License.
      14             : 
      15             : package com.google.gerrit.pgm;
      16             : 
      17             : import com.google.gerrit.entities.Project;
      18             : import com.google.gerrit.extensions.config.FactoryModule;
      19             : import com.google.gerrit.lifecycle.LifecycleManager;
      20             : import com.google.gerrit.pgm.rules.PrologCompiler;
      21             : import com.google.gerrit.pgm.util.SiteProgram;
      22             : import com.google.gerrit.server.git.GitRepositoryManager;
      23             : import com.google.inject.Inject;
      24             : import com.google.inject.Injector;
      25             : import com.googlecode.prolog_cafe.exceptions.CompileException;
      26             : import java.util.ArrayList;
      27             : import java.util.LinkedHashSet;
      28             : import java.util.List;
      29             : import org.eclipse.jgit.lib.Repository;
      30             : import org.kohsuke.args4j.Argument;
      31             : import org.kohsuke.args4j.Option;
      32             : 
      33             : /**
      34             :  * Gets rules.pl at refs/meta/config and compiles into jar file called rules-(sha1 of rules.pl).jar
      35             :  * in (site-path)/cache/rules
      36             :  */
      37           0 : public class Rulec extends SiteProgram {
      38             :   @Option(name = "--all", usage = "recompile all rules")
      39             :   private boolean all;
      40             : 
      41             :   @Option(name = "--quiet", usage = "suppress some messages")
      42             :   private boolean quiet;
      43             : 
      44           0 :   @Argument(
      45             :       index = 0,
      46             :       multiValued = true,
      47             :       metaVar = "PROJECT",
      48             :       usage = "project to compile rules for")
      49             :   private List<String> projectNames = new ArrayList<>();
      50             : 
      51             :   private Injector dbInjector;
      52             : 
      53           0 :   private final LifecycleManager manager = new LifecycleManager();
      54             : 
      55             :   @Inject private GitRepositoryManager gitManager;
      56             : 
      57             :   @Inject private PrologCompiler.Factory jarFactory;
      58             : 
      59             :   @Override
      60             :   public int run() throws Exception {
      61           0 :     dbInjector = createDbInjector();
      62           0 :     manager.add(dbInjector);
      63           0 :     manager.start();
      64           0 :     dbInjector
      65           0 :         .createChildInjector(
      66           0 :             new FactoryModule() {
      67             :               @Override
      68             :               protected void configure() {
      69           0 :                 factory(PrologCompiler.Factory.class);
      70           0 :               }
      71             :             })
      72           0 :         .injectMembers(this);
      73             : 
      74           0 :     LinkedHashSet<Project.NameKey> names = new LinkedHashSet<>();
      75           0 :     for (String name : projectNames) {
      76           0 :       names.add(Project.nameKey(name));
      77           0 :     }
      78           0 :     if (all) {
      79           0 :       names.addAll(gitManager.list());
      80             :     }
      81             : 
      82           0 :     boolean error = false;
      83           0 :     for (Project.NameKey project : names) {
      84           0 :       try (Repository git = gitManager.openRepository(project)) {
      85           0 :         switch (jarFactory.create(git).call()) {
      86             :           case NO_RULES:
      87           0 :             if (!all || projectNames.contains(project.get())) {
      88           0 :               System.err.println("error: No rules.pl in " + project.get());
      89           0 :               error = true;
      90             :             }
      91             :             break;
      92             : 
      93             :           case COMPILED:
      94           0 :             if (!quiet) {
      95           0 :               System.out.format("Compiled %-60s ... SUCCESS", project.get());
      96           0 :               System.out.println();
      97             :             }
      98             :             break;
      99             :         }
     100           0 :       } catch (CompileException err) {
     101           0 :         if (showStackTrace) {
     102           0 :           err.printStackTrace();
     103             :         } else {
     104           0 :           System.err.println("fatal: " + err.getMessage());
     105             :         }
     106           0 :         error = true;
     107           0 :       }
     108           0 :     }
     109             : 
     110           0 :     return !error ? 0 : 1;
     111             :   }
     112             : }