コード例 #1
0
  public void testCreatePool() throws Exception {
    final ObjectFactory objectFactory = ClassicEngineBoot.getInstance().getObjectFactory();
    final IDatabaseDialectService dialectService = objectFactory.get(IDatabaseDialectService.class);
    final DatabaseTypeHelper databaseTypeHelper =
        new DatabaseTypeHelper(dialectService.getDatabaseTypes());

    final DatabaseConnection con = new DatabaseConnection();
    con.setId("Memory");
    con.setName("Memory");
    con.setAccessType(DatabaseAccessType.NATIVE);
    con.setDatabaseType(databaseTypeHelper.getDatabaseTypeByShortName("GENERIC"));
    con.setUsername("pentaho_user");
    con.setPassword("password");
    final HashMap<String, String> attrs = new HashMap<String, String>();
    attrs.put(DatabaseConnection.ATTRIBUTE_CUSTOM_DRIVER_CLASS, "org.hsqldb.jdbcDriver");
    attrs.put(DatabaseConnection.ATTRIBUTE_CUSTOM_URL, "jdbc:hsqldb:mem:SampleData");
    con.setAttributes(attrs);

    final PoolingDataSource poolingDataSource = PooledDatasourceHelper.setupPooledDataSource(con);
    final Connection connection = poolingDataSource.getConnection();
    connection.close();
  }
コード例 #2
0
  public void importFile(IPlatformImportBundle bundle)
      throws PlatformImportException, DomainIdNullException, DomainAlreadyExistsException,
          DomainStorageException, IOException {

    RepositoryFileImportBundle importBundle = (RepositoryFileImportBundle) bundle;
    ZipInputStream zipImportStream = new ZipInputStream(bundle.getInputStream());
    SolutionRepositoryImportSource importSource =
        new SolutionRepositoryImportSource(zipImportStream);
    LocaleFilesProcessor localeFilesProcessor = new LocaleFilesProcessor();
    setOverwriteFile(bundle.overwriteInRepository());
    // importSession.set(ImportSession.getSession());

    IPlatformImporter importer = PentahoSystem.get(IPlatformImporter.class);

    cachedImports = new HashMap<String, RepositoryFileImportBundle.Builder>();

    // Process Manifest Settings
    ExportManifest manifest = getImportSession().getManifest();
    String manifestVersion = null;
    if (manifest != null) {
      manifestVersion = manifest.getManifestInformation().getManifestVersion();
    }
    // Process Metadata
    if (manifest != null) {

      // import the users
      Map<String, List<String>> roleToUserMap = importUsers(manifest.getUserExports());
      // import the roles
      importRoles(manifest.getRoleExports(), roleToUserMap);

      List<ExportManifestMetadata> metadataList = manifest.getMetadataList();
      for (ExportManifestMetadata exportManifestMetadata : metadataList) {

        String domainId = exportManifestMetadata.getDomainId();
        boolean overWriteInRepository = isOverwriteFile();
        RepositoryFileImportBundle.Builder bundleBuilder =
            new RepositoryFileImportBundle.Builder()
                .charSet("UTF-8")
                .hidden(false)
                // let the parent bundle control whether or not to preserve DSW settings
                .preserveDsw(bundle.isPreserveDsw())
                .overwriteFile(overWriteInRepository)
                .mime("text/xmi+xml")
                .withParam("domain-id", domainId);

        cachedImports.put(exportManifestMetadata.getFile(), bundleBuilder);
      }

      // Process Mondrian
      List<ExportManifestMondrian> mondrianList = manifest.getMondrianList();
      for (ExportManifestMondrian exportManifestMondrian : mondrianList) {

        String catName = exportManifestMondrian.getCatalogName();
        Parameters parametersMap = exportManifestMondrian.getParameters();
        StringBuilder parametersStr = new StringBuilder();
        for (String s : parametersMap.keySet()) {
          parametersStr.append(s).append("=").append(parametersMap.get(s)).append(sep);
        }

        RepositoryFileImportBundle.Builder bundleBuilder =
            new RepositoryFileImportBundle.Builder()
                .charSet("UTF_8")
                .hidden(false)
                .name(catName)
                .overwriteFile(isOverwriteFile())
                .mime("application/vnd.pentaho.mondrian+xml")
                .withParam("parameters", parametersStr.toString())
                .withParam("domain-id", catName); // TODO: this is
        // definitely
        // named wrong
        // at the very
        // least.
        // pass as param if not in parameters string
        String xmlaEnabled = "" + exportManifestMondrian.isXmlaEnabled();
        bundleBuilder.withParam("EnableXmla", xmlaEnabled);

        cachedImports.put(exportManifestMondrian.getFile(), bundleBuilder);

        String annotationsFile = exportManifestMondrian.getAnnotationsFile();
        if (annotationsFile != null) {
          RepositoryFileImportBundle.Builder annotationsBundle =
              new RepositoryFileImportBundle.Builder()
                  .path(
                      MondrianCatalogRepositoryHelper.ETC_MONDRIAN_JCR_FOLDER
                          + RepositoryFile.SEPARATOR
                          + catName)
                  .name("annotations.xml")
                  .charSet("UTF_8")
                  .overwriteFile(isOverwriteFile())
                  .mime("text/xml")
                  .hidden(false)
                  .withParam("domain-id", catName);
          cachedImports.put(annotationsFile, annotationsBundle);
        }
      }
    }

    importMetaStore(manifest, bundle.overwriteInRepository());

    for (IRepositoryFileBundle file : importSource.getFiles()) {
      String fileName = file.getFile().getName();
      String actualFilePath = file.getPath();
      if (manifestVersion != null) {
        fileName = ExportFileNameEncoder.decodeZipFileName(fileName);
        actualFilePath = ExportFileNameEncoder.decodeZipFileName(actualFilePath);
      }
      String repositoryFilePath =
          RepositoryFilenameUtils.concat(
              PentahoPlatformImporter.computeBundlePath(actualFilePath), fileName);

      if (this.cachedImports.containsKey(repositoryFilePath)) {

        byte[] bytes = IOUtils.toByteArray(file.getInputStream());
        RepositoryFileImportBundle.Builder builder = cachedImports.get(repositoryFilePath);
        builder.input(new ByteArrayInputStream(bytes));

        importer.importFile(build(builder));
        continue;
      }
      RepositoryFileImportBundle.Builder bundleBuilder = new RepositoryFileImportBundle.Builder();

      InputStream bundleInputStream = null;

      String decodedFilePath = file.getPath();
      RepositoryFile decodedFile = file.getFile();
      if (manifestVersion != null) {
        decodedFile =
            new RepositoryFile.Builder(decodedFile)
                .path(decodedFilePath)
                .name(fileName)
                .title(fileName)
                .build();
        decodedFilePath = ExportFileNameEncoder.decodeZipFileName(file.getPath());
      }

      if (file.getFile().isFolder()) {
        bundleBuilder.mime("text/directory");
        bundleBuilder.file(decodedFile);
        fileName = repositoryFilePath;
        repositoryFilePath = importBundle.getPath();
      } else {
        byte[] bytes = IOUtils.toByteArray(file.getInputStream());
        bundleInputStream = new ByteArrayInputStream(bytes);
        // If is locale file store it for later processing.
        if (localeFilesProcessor.isLocaleFile(file, importBundle.getPath(), bytes)) {
          log.trace("Skipping [" + repositoryFilePath + "], it is a locale property file");
          continue;
        }
        bundleBuilder.input(bundleInputStream);
        bundleBuilder.mime(solutionHelper.getMime(fileName));

        String filePath =
            (decodedFilePath.equals("/") || decodedFilePath.equals("\\")) ? "" : decodedFilePath;
        repositoryFilePath = RepositoryFilenameUtils.concat(importBundle.getPath(), filePath);
      }

      bundleBuilder.name(fileName);
      bundleBuilder.path(repositoryFilePath);

      String sourcePath;
      if (decodedFilePath.startsWith("/")) {
        sourcePath = RepositoryFilenameUtils.concat(decodedFilePath.substring(1), fileName);
      } else {
        if (file.getFile().isFolder()) {
          sourcePath = fileName;
        } else {
          sourcePath = RepositoryFilenameUtils.concat(decodedFilePath, fileName);
        }
      }

      // This clause was added for processing ivb files so that it would not try process acls on
      // folders that the user
      // may not have rights to such as /home or /public
      if (manifest != null
          && manifest.getExportManifestEntity(sourcePath) == null
          && file.getFile().isFolder()) {
        continue;
      }

      getImportSession().setCurrentManifestKey(sourcePath);

      bundleBuilder.charSet(bundle.getCharset());
      bundleBuilder.overwriteFile(bundle.overwriteInRepository());
      bundleBuilder.hidden(isFileHidden(bundle, sourcePath));
      bundleBuilder.applyAclSettings(bundle.isApplyAclSettings());
      bundleBuilder.retainOwnership(bundle.isRetainOwnership());
      bundleBuilder.overwriteAclSettings(bundle.isOverwriteAclSettings());
      bundleBuilder.acl(getImportSession().processAclForFile(sourcePath));
      IPlatformImportBundle platformImportBundle = build(bundleBuilder);
      importer.importFile(platformImportBundle);

      if (bundleInputStream != null) {
        bundleInputStream.close();
        bundleInputStream = null;
      }
    }
    if (manifest != null) {
      List<JobScheduleRequest> scheduleList = manifest.getScheduleList();
      if (scheduleList != null) {
        SchedulerResource schedulerResource = new SchedulerResource();
        for (JobScheduleRequest jobScheduleRequest : scheduleList) {
          try {
            Response response = createSchedulerJob(schedulerResource, jobScheduleRequest);
            if (response.getStatus() == Response.Status.OK.getStatusCode()) {
              if (response.getEntity() != null) {
                // get the schedule job id from the response and add it to the import session
                ImportSession.getSession()
                    .addImportedScheduleJobId(response.getEntity().toString());
              }
            }
          } catch (Exception e) {
            // there is a scenario where if the file scheduled has a space in the path, that it
            // won't work. the di server
            // replaces spaces with underscores and the export mechanism can't determine if it needs
            // this to happen or not
            // so, if we failed to import and there is a space in the path, try again but this time
            // with replacing the space(s)
            if (jobScheduleRequest.getInputFile().contains(" ")
                || jobScheduleRequest.getOutputFile().contains(" ")) {
              log.info(
                  "Could not import schedule, attempting to replace spaces with underscores and retrying: "
                      + jobScheduleRequest.getInputFile());

              jobScheduleRequest.setInputFile(
                  jobScheduleRequest.getInputFile().replaceAll(" ", "_"));
              jobScheduleRequest.setOutputFile(
                  jobScheduleRequest.getOutputFile().replaceAll(" ", "_"));
              try {
                Response response = createSchedulerJob(schedulerResource, jobScheduleRequest);
                if (response.getStatus() == Response.Status.OK.getStatusCode()) {
                  if (response.getEntity() != null) {
                    // get the schedule job id from the response and add it to the import session
                    ImportSession.getSession()
                        .addImportedScheduleJobId(response.getEntity().toString());
                  }
                }
              } catch (Exception ex) {
                throw new PlatformImportException(
                    Messages.getInstance()
                        .getString(
                            "SolutionImportHandler.ERROR_0001_ERROR_CREATING_SCHEDULE",
                            e.getMessage()));
              }
            } else {
              throw new PlatformImportException(
                  Messages.getInstance()
                      .getString(
                          "SolutionImportHandler.ERROR_0001_ERROR_CREATING_SCHEDULE",
                          e.getMessage()));
            }
          }
        }
      }

      // Add Pentaho Connections
      List<org.pentaho.database.model.DatabaseConnection> datasourceList =
          manifest.getDatasourceList();
      if (datasourceList != null) {
        IDatasourceMgmtService datasourceMgmtSvc = PentahoSystem.get(IDatasourceMgmtService.class);
        for (org.pentaho.database.model.DatabaseConnection databaseConnection : datasourceList) {
          if (databaseConnection.getDatabaseType() == null) {
            // don't try to import the connection if there is no type it will cause an error
            // However, if this is the DI Server, and the connection is defined in a ktr, it will
            // import automatically
            log.warn(
                "Can't import connection "
                    + databaseConnection.getName()
                    + " because it doesn't have a databaseType");
            continue;
          }
          try {
            IDatabaseConnection existingDBConnection =
                datasourceMgmtSvc.getDatasourceByName(databaseConnection.getName());
            if (existingDBConnection != null && existingDBConnection.getName() != null) {
              if (isOverwriteFile()) {
                databaseConnection.setId(existingDBConnection.getId());
                datasourceMgmtSvc.updateDatasourceByName(
                    databaseConnection.getName(), databaseConnection);
              }
            } else {
              datasourceMgmtSvc.createDatasource(databaseConnection);
            }
          } catch (Exception e) {
            e.printStackTrace();
          }
        }
      }
    }
    // Process locale files.
    localeFilesProcessor.processLocaleFiles(importer);
  }