Java Dependency类代码示例

import org.apache.zeppelin.dep.Dependency; //导入依赖的package包/类
public InterpreterSetting createNewSetting(String name, String group,
    List<Dependency> dependencies, InterpreterOption option, Map<String, InterpreterProperty> p)
    throws IOException {

  if (name.indexOf(".") >= 0) {
    throw new IOException("'.' is invalid for InterpreterSetting name.");
  }
  // check if name is existed
  for (InterpreterSetting interpreterSetting : interpreterSettings.values()) {
    if (interpreterSetting.getName().equals(name)) {
      throw new IOException("Interpreter " + name + " already existed");
    }
  }
  InterpreterSetting setting = new InterpreterSetting(interpreterSettingTemplates.get(group));
  setting.setName(name);
  setting.setGroup(group);
  //TODO(zjffdu) Should use setDependencies
  setting.appendDependencies(dependencies);
  setting.setInterpreterOption(option);
  setting.setProperties(p);
  initInterpreterSetting(setting);
  interpreterSettings.put(setting.getId(), setting);
  saveToFile();
  return setting;
}
 

import org.apache.zeppelin.dep.Dependency; //导入依赖的package包/类
/**
 * Change interpreter properties and restart
 */
public void setPropertyAndRestart(String id, InterpreterOption option,
                                  Map<String, InterpreterProperty> properties,
                                  List<Dependency> dependencies)
    throws InterpreterException, IOException {
  synchronized (interpreterSettings) {
    InterpreterSetting intpSetting = interpreterSettings.get(id);
    if (intpSetting != null) {
      try {
        intpSetting.close();
        intpSetting.setOption(option);
        intpSetting.setProperties(properties);
        intpSetting.setDependencies(dependencies);
        intpSetting.postProcessing();
        saveToFile();
      } catch (Exception e) {
        loadFromFile();
        throw new IOException(e);
      }
    } else {
      throw new InterpreterException("Interpreter setting id " + id + " not found");
    }
  }
}
 

import org.apache.zeppelin.dep.Dependency; //导入依赖的package包/类
/**
 * fetch all artifacts
 * @return
 * @throws MalformedURLException
 * @throws ArtifactResolutionException
 * @throws DependencyResolutionException
 */
public List<File> fetch() throws MalformedURLException,
    DependencyResolutionException, ArtifactResolutionException {

  for (Dependency dep : dependencies) {
    if (!dep.isLocalFsArtifact()) {
      List<ArtifactResult> artifacts = fetchArtifactWithDep(dep);
      for (ArtifactResult artifact : artifacts) {
        if (dep.isDist()) {
          filesDist.add(artifact.getArtifact().getFile());
        }
        files.add(artifact.getArtifact().getFile());
      }
    } else {
      if (dep.isDist()) {
        filesDist.add(new File(dep.getGroupArtifactVersion()));
      }
      files.add(new File(dep.getGroupArtifactVersion()));
    }
  }

  return files;
}
 

import org.apache.zeppelin.dep.Dependency; //导入依赖的package包/类
void appendDependencies(List<Dependency> dependencies) {
  for (Dependency dependency : dependencies) {
    if (!this.dependencies.contains(dependency)) {
      this.dependencies.add(dependency);
    }
  }
  loadInterpreterDependencies();
}
 

import org.apache.zeppelin.dep.Dependency; //导入依赖的package包/类
/**
 * Overwrite dependency jar under local-repo/{interpreterId}
 * if jar file in original path is changed
 */
private void copyDependenciesFromLocalPath(final InterpreterSetting setting) {
  setting.setStatus(InterpreterSetting.Status.DOWNLOADING_DEPENDENCIES);
  synchronized (interpreterSettings) {
    final Thread t = new Thread() {
      public void run() {
        try {
          List<Dependency> deps = setting.getDependencies();
          if (deps != null) {
            for (Dependency d : deps) {
              File destDir = new File(
                  conf.getRelativeDir(ConfVars.ZEPPELIN_DEP_LOCALREPO));

              int numSplits = d.getGroupArtifactVersion().split(":").length;
              if (!(numSplits >= 3 && numSplits <= 6)) {
                dependencyResolver.copyLocalDependency(d.getGroupArtifactVersion(),
                    new File(destDir, setting.getId()));
              }
            }
          }
          setting.setStatus(InterpreterSetting.Status.READY);
        } catch (Exception e) {
          LOGGER.error(String.format("Error while copying deps for interpreter group : %s," +
                  " go to interpreter setting page click on edit and save it again to make " +
                  "this interpreter work properly.",
              setting.getGroup()), e);
          setting.setErrorReason(e.getLocalizedMessage());
          setting.setStatus(InterpreterSetting.Status.ERROR);
        } finally {

        }
      }
    };
    t.start();
  }
}
 

import org.apache.zeppelin.dep.Dependency; //导入依赖的package包/类
public Dependency load(String lib) {
  Dependency dep = new Dependency(lib);

  if (dependencies.contains(dep)) {
    dependencies.remove(dep);
  }
  dependencies.add(dep);
  return dep;
}
 

import org.apache.zeppelin.dep.Dependency; //导入依赖的package包/类
public Builder setDependencies(List<Dependency> dependencies) {
  interpreterSetting.dependencies = dependencies;
  return this;
}
 

import org.apache.zeppelin.dep.Dependency; //导入依赖的package包/类
public List<Dependency> getDependencies() {
  return dependencies;
}
 

import org.apache.zeppelin.dep.Dependency; //导入依赖的package包/类
private void registerInterpreterSetting(List<RegisteredInterpreter> registeredInterpreters,
                                        String interpreterDir) throws IOException {

  Map<String, DefaultInterpreterProperty> properties = new HashMap<>();
  List<InterpreterInfo> interpreterInfos = new ArrayList<>();
  InterpreterOption option = defaultOption;
  String group = null;
  InterpreterRunner runner = null;
  for (RegisteredInterpreter registeredInterpreter : registeredInterpreters) {
    //TODO(zjffdu) merge RegisteredInterpreter & InterpreterInfo
    InterpreterInfo interpreterInfo =
        new InterpreterInfo(registeredInterpreter.getClassName(), registeredInterpreter.getName(),
            registeredInterpreter.isDefaultInterpreter(), registeredInterpreter.getEditor());
    group = registeredInterpreter.getGroup();
    runner = registeredInterpreter.getRunner();
    // use defaultOption if it is not specified in interpreter-setting.json
    if (registeredInterpreter.getOption() != null) {
      option = registeredInterpreter.getOption();
    }
    properties.putAll(registeredInterpreter.getProperties());
    interpreterInfos.add(interpreterInfo);
  }

  InterpreterSetting interpreterSettingTemplate = new InterpreterSetting.Builder()
      .setGroup(group)
      .setName(group)
      .setInterpreterInfos(interpreterInfos)
      .setProperties(properties)
      .setDependencies(new ArrayList<Dependency>())
      .setOption(option)
      .setRunner(runner)
      .setInterpreterDir(interpreterDir)
      .setRunner(runner)
      .setConf(conf)
      .setIntepreterSettingManager(this)
      .create();

  LOGGER.info("Register InterpreterSettingTemplate & InterpreterSetting: {}",
      interpreterSettingTemplate.getName());
  interpreterSettingTemplates.put(interpreterSettingTemplate.getName(),
      interpreterSettingTemplate);

  InterpreterSetting interpreterSetting = new InterpreterSetting(interpreterSettingTemplate);
  initInterpreterSetting(interpreterSetting);
}
 

import org.apache.zeppelin.dep.Dependency; //导入依赖的package包/类
public UpdateInterpreterSettingRequest(Map<String, InterpreterProperty> properties,
    List<Dependency> dependencies, InterpreterOption option) {
  this.properties = properties;
  this.dependencies = dependencies;
  this.option = option;
}
 

import org.apache.zeppelin.dep.Dependency; //导入依赖的package包/类
public UpdateInterpreterSettingRequest(Map<String, InterpreterProperty> properties,
        List<Dependency> dependencies, InterpreterOption option) {
  this.properties = properties;
  this.dependencies = dependencies;
  this.option = option;
}