public void pkgList(List<? extends Package> packagesList) {
   CommandInfo cmdInfo = cset.newCommandInfo(CommandInfo.CMD_LIST);
   try {
     if (packagesList.isEmpty()) {
       log.info("None");
     } else {
       NuxeoConnectClient.getPackageManager().sort(packagesList);
       StringBuilder sb = new StringBuilder();
       for (Package pkg : packagesList) {
         newPackageInfo(cmdInfo, pkg);
         String packageDescription = PackageState.getByValue(pkg.getState()).getLabel();
         packageDescription = String.format("%6s %11s\t", pkg.getType(), packageDescription);
         if (pkg.getState() == PackageState.REMOTE.getValue()
             && pkg.getType() != PackageType.STUDIO
             && pkg.getVisibility() != PackageVisibility.PUBLIC
             && !LogicalInstanceIdentifier.isRegistered()) {
           packageDescription += "Registration required for ";
         }
         packageDescription += String.format("%s (id: %s)\n", pkg.getName(), pkg.getId());
         sb.append(packageDescription);
       }
       log.info(sb.toString());
     }
   } catch (Exception e) {
     log.error(e);
     cmdInfo.exitCode = 1;
   }
 }
 protected boolean pkgUpgradeByType(PackageType type) {
   List<DownloadablePackage> upgrades =
       NuxeoConnectClient.getPackageManager().listUpdatePackages(type, targetPlatform);
   List<String> upgradeIds = new ArrayList<String>();
   for (DownloadablePackage upgrade : upgrades) {
     upgradeIds.add(upgrade.getId());
   }
   return pkgRequest(null, upgradeIds, null, null);
 }
 protected boolean isRemotePackageId(String pkgId) {
   List<DownloadablePackage> remotePackages =
       NuxeoConnectClient.getPackageManager().listAllPackages();
   boolean foundId = false;
   for (DownloadablePackage pkg : remotePackages) {
     if (pkg.getId().equals(pkgId)) {
       foundId = true;
       break;
     }
   }
   return foundId;
 }
 public ConnectBroker(Environment env) throws IOException, PackageException {
   this.env = env;
   service = new StandaloneUpdateService(env);
   service.initialize();
   cbHolder = new StandaloneCallbackHolder(env, service);
   NuxeoConnectClient.setCallBackHolder(cbHolder);
   targetPlatform =
       env.getProperty(Environment.DISTRIBUTION_NAME)
           + "-"
           + env.getProperty(Environment.DISTRIBUTION_VERSION);
   distributionMPDir = env.getProperty(PARAM_MP_DIR, DISTRIBUTION_MP_DIR_DEFAULT);
 }
  // Wrap connect client services as Nuxeo Services
  public <T> T getAdapter(Class<T> adapter) {

    if (adapter.getCanonicalName().equals(ConnectConnector.class.getCanonicalName())) {
      return adapter.cast(NuxeoConnectClient.getConnectConnector());
    }

    if (adapter.getCanonicalName().equals(ConnectRegistrationService.class.getCanonicalName())) {
      return adapter.cast(NuxeoConnectClient.getConnectRegistrationService());
    }

    if (adapter.getCanonicalName().equals(ConnectDownloadManager.class.getCanonicalName())) {
      return adapter.cast(NuxeoConnectClient.getDownloadManager());
    }

    if (adapter.getCanonicalName().equals(PackageManager.class.getCanonicalName())) {
      return adapter.cast(NuxeoConnectClient.getPackageManager());
    }

    if (adapter.getCanonicalName().equals(PackageUpdateService.class.getCanonicalName())) {
      return adapter.cast(NuxeoConnectClient.getPackageUpdateService());
    }

    return adapter.cast(this);
  }
 protected Map<String, PackageDefinition> getDistributionDefinitions(List<String> md5Filenames) {
   Map<String, PackageDefinition> allDefinitions = new HashMap<String, PackageDefinition>();
   if (md5Filenames == null) {
     return allDefinitions;
   }
   for (String md5Filename : md5Filenames) {
     File md5File = new File(distributionMPDir, md5Filename);
     if (!md5File.exists()) {
       // distribution file has been deleted
       continue;
     }
     ZipFile zipFile;
     try {
       zipFile = new ZipFile(md5File);
     } catch (ZipException e) {
       log.warn("Unzip error reading file " + md5File, e);
       continue;
     } catch (IOException e) {
       log.warn("Could not read file " + md5File, e);
       continue;
     }
     try {
       ZipEntry zipEntry = zipFile.getEntry("package.xml");
       InputStream in = zipFile.getInputStream(zipEntry);
       PackageDefinition pd = NuxeoConnectClient.getPackageUpdateService().loadPackage(in);
       allDefinitions.put(md5Filename, pd);
     } catch (Exception e) {
       log.error("Could not read package description", e);
       continue;
     } finally {
       try {
         zipFile.close();
       } catch (IOException e) {
         log.warn("Unexpected error closing file " + md5File, e);
       }
     }
   }
   return allDefinitions;
 }
 @Override
 public void activate(ComponentContext context) throws Exception {
   NuxeoConnectClient.setCallBackHolder(new NuxeoCallbackHolder());
 }
 public void pkgListAll() {
   log.info("All packages:");
   pkgList(NuxeoConnectClient.getPackageManager().listAllPackages());
 }
 protected String getRemotePackageIdFromName(String pkgName) {
   return getBestIdForNameInList(
       pkgName, NuxeoConnectClient.getPackageManager().listAllPackages());
 }
示例#10
0
 public void refreshCache() {
   getPackageManager().flushCache();
   NuxeoConnectClient.getPackageManager().listAllPackages();
 }
示例#11
0
 public PackageManager getPackageManager() {
   return NuxeoConnectClient.getPackageManager();
 }
示例#12
0
  @SuppressWarnings("unchecked")
  public boolean pkgRequest(
      List<String> pkgsToAdd,
      List<String> pkgsToInstall,
      List<String> pkgsToUninstall,
      List<String> pkgsToRemove) {
    boolean cmdOk = true;
    // Add local files
    cmdOk = pkgAdd(pkgsToAdd);
    // Build solver request
    List<String> solverInstall = new ArrayList<String>();
    List<String> solverRemove = new ArrayList<String>();
    List<String> solverUpgrade = new ArrayList<String>();
    if (pkgsToInstall != null) {
      // If install request is a file name, add to cache and get the id
      List<String> namesOrIdsToInstall = new ArrayList<String>();
      for (String pkgToInstall : pkgsToInstall) {
        if (isLocalPackageFile(pkgToInstall)) {
          LocalPackage addedPkg = pkgAdd(pkgToInstall);
          if (addedPkg != null) {
            namesOrIdsToInstall.add(addedPkg.getId());
          } else {
            cmdOk = false;
          }
          // TODO: set flag to prefer local package
        } else {
          namesOrIdsToInstall.add(pkgToInstall);
        }
      }
      // Check whether we have new installs or upgrades
      for (String pkgToInstall : namesOrIdsToInstall) {
        Map<String, DownloadablePackage> allPackagesByID =
            NuxeoConnectClient.getPackageManager().getAllPackagesByID();
        DownloadablePackage pkg = allPackagesByID.get(pkgToInstall);
        if (pkg != null) {
          // This is a known ID
          if (isInstalledPackageName(pkg.getName())) {
            // The package is installed in another version
            solverUpgrade.add(pkgToInstall);
          } else {
            // The package isn't installed yet
            solverInstall.add(pkgToInstall);
          }
        } else {
          // This is a name (or a non-existing ID)
          String id = getInstalledPackageIdFromName(pkgToInstall);
          if (id != null) {
            // The package is installed in another version
            solverUpgrade.add(id);
          } else {
            // The package isn't installed yet
            solverInstall.add(pkgToInstall);
          }
        }
      }
    }
    if (pkgsToUninstall != null) {
      solverRemove.addAll(pkgsToUninstall);
    }
    if (pkgsToRemove != null) {
      // Add packages to remove to uninstall list
      solverRemove.addAll(pkgsToRemove);
    }
    if ((solverInstall.size() != 0) || (solverRemove.size() != 0) || (solverUpgrade.size() != 0)) {
      // Check whether we need to relax restriction to targetPlatform
      String requestPlatform = targetPlatform;
      List<String> requestPackages = new ArrayList<String>();
      requestPackages.addAll(solverInstall);
      requestPackages.addAll(solverRemove);
      requestPackages.addAll(solverUpgrade);
      try {
        String nonCompliantPkg =
            getPackageManager().getNonCompliant(requestPackages, targetPlatform);
        if (nonCompliantPkg != null) {
          requestPlatform = null;
          if ("ask".equalsIgnoreCase(relax)) {
            relax =
                readConsole(
                    "Package %s is not available on platform version %s.\n"
                        + "Do you want to relax the constraint (yes/no)? [no] ",
                    "no", nonCompliantPkg, targetPlatform);
          }

          if (Boolean.parseBoolean(relax)) {
            log.warn(
                String.format(
                    "Relax restriction to target platform %s because of package %s",
                    targetPlatform, nonCompliantPkg));
          } else {
            throw new PackageException(
                String.format(
                    "Package %s is not available on platform version %s (relax is not allowed)",
                    nonCompliantPkg, targetPlatform));
          }
        }
      } catch (PackageException e) {
        log.error(e);
        return false;
      }

      log.debug("solverInstall: " + solverInstall);
      log.debug("solverRemove: " + solverRemove);
      log.debug("solverUpgrade: " + solverUpgrade);
      DependencyResolution resolution =
          getPackageManager()
              .resolveDependencies(solverInstall, solverRemove, solverUpgrade, requestPlatform);
      log.info(resolution);
      if (resolution.isFailed()) {
        return false;
      }
      if (resolution.isEmpty()) {
        pkgRemove(pkgsToRemove);
        return cmdOk;
      }
      if ("ask".equalsIgnoreCase(accept)) {
        accept = readConsole("Do you want to continue (yes/no)? [yes] ", "yes");
      }
      if (!Boolean.parseBoolean(accept)) {
        log.warn("Exit");
        return false;
      }

      List<String> packageIdsToRemove = resolution.getOrderedPackageIdsToRemove();
      List<String> packageIdsToUpgrade = resolution.getUpgradePackageIds();
      List<String> packageIdsToInstall = resolution.getOrderedPackageIdsToInstall();
      List<String> packagesIdsToReInstall = new ArrayList<String>();

      // Download remote packages
      if (!downloadPackages(resolution.getDownloadPackageIds())) {
        log.error("Aborting packages change request");
        return false;
      }

      // Uninstall
      if (!packageIdsToUpgrade.isEmpty()) {
        // Add packages to upgrade to uninstall list
        // Don't use IDs to avoid downgrade instead of uninstall
        packageIdsToRemove.addAll(resolution.getLocalPackagesToUpgrade().keySet());
        DependencyResolution uninstallResolution =
            getPackageManager()
                .resolveDependencies(null, packageIdsToRemove, null, requestPlatform);
        log.debug("Sub-resolution (uninstall) " + uninstallResolution);
        if (uninstallResolution.isFailed()) {
          return false;
        }
        List<String> newPackageIdsToRemove = uninstallResolution.getOrderedPackageIdsToRemove();
        packagesIdsToReInstall = ListUtils.subtract(newPackageIdsToRemove, packageIdsToRemove);
        packagesIdsToReInstall.removeAll(packageIdsToUpgrade);
        packageIdsToRemove = newPackageIdsToRemove;
      }
      if (!pkgUninstall(packageIdsToRemove)) {
        return false;
      }

      // Install
      if (!packagesIdsToReInstall.isEmpty()) {
        // Add list of packages uninstalled because of upgrade
        packageIdsToInstall.addAll(packagesIdsToReInstall);
        DependencyResolution installResolution =
            getPackageManager()
                .resolveDependencies(packageIdsToInstall, null, null, requestPlatform);
        log.debug("Sub-resolution (install) " + installResolution);
        if (installResolution.isFailed()) {
          return false;
        }
        packageIdsToInstall = installResolution.getOrderedPackageIdsToInstall();
      }
      if (!pkgInstall(packageIdsToInstall)) {
        return false;
      }

      pkgRemove(pkgsToRemove);
    }
    return cmdOk;
  }