001/* 002 * (C) Copyright 2006-2016 Nuxeo SA (http://nuxeo.com/) and others. 003 * 004 * Licensed under the Apache License, Version 2.0 (the "License"); 005 * you may not use this file except in compliance with the License. 006 * You may obtain a copy of the License at 007 * 008 * http://www.apache.org/licenses/LICENSE-2.0 009 * 010 * Unless required by applicable law or agreed to in writing, software 011 * distributed under the License is distributed on an "AS IS" BASIS, 012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 013 * See the License for the specific language governing permissions and 014 * limitations under the License. 015 * 016 * Contributors: 017 * bstefanescu 018 * jcarsique 019 * Yannis JULIENNE 020 */ 021package org.nuxeo.connect.update.xml; 022 023import org.apache.commons.lang.mutable.MutableObject; 024import org.nuxeo.common.xmap.annotation.XNode; 025import org.nuxeo.common.xmap.annotation.XNodeList; 026import org.nuxeo.common.xmap.annotation.XObject; 027import org.nuxeo.connect.data.PackageDescriptor; 028import org.nuxeo.connect.update.NuxeoValidationState; 029import org.nuxeo.connect.update.PackageDependency; 030import org.nuxeo.connect.update.PackageState; 031import org.nuxeo.connect.update.PackageType; 032import org.nuxeo.connect.update.PackageVisibility; 033import org.nuxeo.connect.update.ProductionState; 034import org.nuxeo.connect.update.Validator; 035import org.nuxeo.connect.update.Version; 036import org.nuxeo.connect.update.model.PackageDefinition; 037import org.nuxeo.connect.update.model.TaskDefinition; 038import org.nuxeo.connect.update.task.Task; 039 040/** 041 * @author <a href="mailto:bs@nuxeo.com">Bogdan Stefanescu</a> 042 */ 043@XObject("package") 044public class PackageDefinitionImpl implements PackageDefinition { 045 046 @XNode("@name") 047 protected String name; 048 049 @XNode("@version") 050 protected Version version; 051 052 @XNode("@type") 053 protected PackageType type; 054 055 @XNode("visibility") 056 protected PackageVisibility visibility; 057 058 @XNode("title") 059 protected String title; 060 061 @XNode("description") 062 protected String description; 063 064 @XNode("classifier") 065 protected String classifier; 066 067 @XNode("vendor") 068 protected String vendor; 069 070 @XNode("home-page") 071 protected String homePage; 072 073 @XNode("supported") 074 protected boolean supported = false; 075 076 @XNode("hotreload-support") 077 protected boolean hotReloadSupport = false; 078 079 @XNode("require-terms-and-conditions-acceptance") 080 protected boolean requireTermsAndConditionsAcceptance = false; 081 082 protected NuxeoValidationState validationState = NuxeoValidationState.NONE; 083 084 protected ProductionState productionState = ProductionState.TESTING; 085 086 /** 087 * The license name. E.g. LGPL, BSD etc. 088 */ 089 @XNode("license") 090 protected String license; 091 092 /** 093 * A license URL. If no specified the license.txt file in the package is the license content 094 */ 095 @XNode("license-url") 096 protected String licenseUrl; 097 098 /** 099 * The target platforms where this package may be installed. 100 */ 101 protected String[] platforms; 102 103 /** 104 * The dependency value format is: <code>package_name[:package_min_version[:package_max_version]]</code> if no min 105 * and max version are specified the the last version should be used. 106 */ 107 @XNodeList(value = "dependencies/package", type = PackageDependency[].class, componentType = PackageDependency.class) 108 protected PackageDependency[] dependencies; 109 110 /** 111 * The optional dependencies are defined for ordering purpose, to make sure that if they are being installed along 112 * with the current package, they will be ordered first. 113 */ 114 @XNodeList(value = "optional-dependencies/package", type = PackageDependency[].class, componentType = PackageDependency.class) 115 protected PackageDependency[] optionalDependencies; 116 117 /** 118 * The conflict value format is: <code>package_name[:package_min_version[:package_max_version]]</code> if no min and 119 * max version are specified the the last version should be used. 120 */ 121 @XNodeList(value = "conflicts/package", type = PackageDependency[].class, componentType = PackageDependency.class) 122 protected PackageDependency[] conflicts; 123 124 /** 125 * The provides value format is: <code>package_name[:package_min_version[:package_max_version]]</code> if no min and 126 * max version are specified the the last version should be used. 127 */ 128 @XNodeList(value = "provides/package", type = PackageDependency[].class, componentType = PackageDependency.class) 129 protected PackageDependency[] provides; 130 131 /** 132 * A class implementing {@link Task}. if not specified the default implementation will be used 133 */ 134 @XNode("installer") 135 protected TaskDefinitionImpl installer; 136 137 /** 138 * A class implementing {@link Task}. if not specified the default implementation will be used 139 */ 140 @XNode("uninstaller") 141 protected TaskDefinitionImpl uninstaller; 142 143 /** 144 * A class implementing {@link Validator}. If not specified not post install validation will be done 145 */ 146 @XNode("validator") 147 protected String validator; 148 149 @XNode("nuxeo-validation") 150 protected void initNuxeoValidationState(String value) { 151 NuxeoValidationState targetState = NuxeoValidationState.getByValue(value); 152 if (targetState != null) { 153 validationState = targetState; 154 } 155 } 156 157 @XNode("production-state") 158 protected void initProductionState(String value) { 159 ProductionState targetState = ProductionState.getByValue(value); 160 if (targetState != null) { 161 productionState = targetState; 162 } 163 } 164 165 @Override 166 public String getId() { 167 if (version == null) { 168 return name; 169 } else { 170 return name + "-" + version.toString(); 171 } 172 } 173 174 @Override 175 public String getName() { 176 return name; 177 } 178 179 @Override 180 public void setName(String name) { 181 this.name = name; 182 dependencies = PackageDescriptor.fixDependencies(name, dependencies); 183 } 184 185 @Override 186 public Version getVersion() { 187 return version; 188 } 189 190 @Override 191 public void setVersion(Version version) { 192 this.version = version; 193 } 194 195 @Override 196 public String getTitle() { 197 return title; 198 } 199 200 @Override 201 public void setTitle(String title) { 202 this.title = title; 203 } 204 205 @Override 206 public String getDescription() { 207 return description; 208 } 209 210 @Override 211 public void setDescription(String description) { 212 this.description = description; 213 } 214 215 @Override 216 public PackageType getType() { 217 return type; 218 } 219 220 @Override 221 public void setType(PackageType type) { 222 this.type = type; 223 } 224 225 @Override 226 public String getClassifier() { 227 return classifier; 228 } 229 230 @Override 231 public void setClassifier(String classifier) { 232 this.classifier = classifier; 233 } 234 235 @Override 236 public String getHomePage() { 237 return homePage; 238 } 239 240 @Override 241 public void setHomePage(String homePage) { 242 this.homePage = homePage; 243 } 244 245 @Deprecated 246 @Override 247 public String getLicense() { 248 return getLicenseType(); 249 } 250 251 @Override 252 public String getLicenseType() { 253 return license; 254 } 255 256 @Deprecated 257 @Override 258 public void setLicense(String license) { 259 setLicenseType(license); 260 } 261 262 @Override 263 public void setLicenseType(String license) { 264 this.license = license; 265 } 266 267 @Override 268 public String getLicenseUrl() { 269 return licenseUrl; 270 } 271 272 @Override 273 public void setLicenseUrl(String licenseUrl) { 274 this.licenseUrl = licenseUrl; 275 } 276 277 @Deprecated 278 @Override 279 public String[] getPlatforms() { 280 return getTargetPlatforms(); 281 } 282 283 @Override 284 public String[] getTargetPlatforms() { 285 return platforms; 286 } 287 288 @Deprecated 289 @Override 290 public void setPlatforms(String[] platforms) { 291 setTargetPlatforms(platforms); 292 } 293 294 @XNodeList(value = "platforms/platform", type = String[].class, componentType = String.class) 295 @Override 296 public void setTargetPlatforms(String[] platforms) { 297 MutableObject packageDependencies = new MutableObject(); 298 this.platforms = PackageDescriptor.fixTargetPlatforms(name, platforms, packageDependencies); 299 setDependencies((PackageDependency[]) packageDependencies.getValue()); 300 } 301 302 @Override 303 public PackageDependency[] getDependencies() { 304 return dependencies; 305 } 306 307 @Override 308 public PackageDependency[] getOptionalDependencies() { 309 return optionalDependencies; 310 } 311 312 @Override 313 public void setDependencies(PackageDependency[] dependencies) { 314 this.dependencies = PackageDescriptor.addPackageDependencies(this.dependencies, dependencies); 315 } 316 317 @Override 318 public PackageDependency[] getConflicts() { 319 return conflicts; 320 } 321 322 @Override 323 public void setConflicts(PackageDependency[] conflicts) { 324 this.conflicts = conflicts; 325 } 326 327 @Override 328 public PackageDependency[] getProvides() { 329 return provides; 330 } 331 332 @Override 333 public void setProvides(PackageDependency[] provides) { 334 this.provides = provides; 335 } 336 337 @Override 338 public String getVendor() { 339 return vendor; 340 } 341 342 @Override 343 public void setVendor(String vendor) { 344 this.vendor = vendor; 345 } 346 347 @Override 348 public TaskDefinition getInstaller() { 349 return installer; 350 } 351 352 @Override 353 public void setInstaller(TaskDefinition installer) { 354 if (installer instanceof TaskDefinitionImpl) { 355 this.installer = (TaskDefinitionImpl) installer; 356 } else { 357 this.installer = new TaskDefinitionImpl(installer.getType(), installer.getRequireRestart()); 358 } 359 } 360 361 @Override 362 public TaskDefinition getUninstaller() { 363 return uninstaller; 364 } 365 366 @Override 367 public void setUninstaller(TaskDefinition uninstaller) { 368 if (uninstaller instanceof TaskDefinitionImpl) { 369 this.uninstaller = (TaskDefinitionImpl) uninstaller; 370 } else { 371 this.uninstaller = new TaskDefinitionImpl(uninstaller.getType(), uninstaller.getRequireRestart()); 372 } 373 } 374 375 @Override 376 public String getValidator() { 377 return validator; 378 } 379 380 @Override 381 public void setValidator(String validator) { 382 this.validator = validator; 383 } 384 385 @Override 386 public void setSupported(boolean supported) { 387 this.supported = supported; 388 } 389 390 @Override 391 public void setHotReloadSupport(boolean hotReloadSupport) { 392 this.hotReloadSupport = hotReloadSupport; 393 } 394 395 @Override 396 public void setValidationState(NuxeoValidationState validationState) { 397 this.validationState = validationState; 398 } 399 400 @Override 401 public void setProductionState(ProductionState productionState) { 402 this.productionState = productionState; 403 } 404 405 @Deprecated 406 public void write(XmlWriter writer) { 407 writer.writeXmlDecl(); 408 409 writer.start("package"); 410 writer.attr("name", name); 411 if (version != null) { 412 writer.attr("version", version.toString()); 413 } 414 if (type != null) { 415 writer.attr("type", type.getValue()); 416 } 417 if (visibility != null) { 418 writer.attr("visibility", visibility.toString()); 419 } 420 writer.startContent(); 421 writer.element("title", title); 422 writer.element("description", description); 423 writer.element("classifier", classifier); 424 writer.element("vendor", vendor); 425 writer.element("home-page", homePage); 426 writer.element("license", license); 427 writer.element("license-url", licenseUrl); 428 writer.element("hotreload-support", Boolean.valueOf(hotReloadSupport).toString()); 429 writer.element("supported", Boolean.valueOf(supported).toString()); 430 writer.element("require-terms-and-conditions-acceptance", 431 Boolean.valueOf(requireTermsAndConditionsAcceptance).toString()); 432 writer.element("production-state", productionState.toString()); 433 writer.element("nuxeo-validation", validationState.toString()); 434 if (platforms != null) { 435 writer.start("platforms"); 436 writer.startContent(); 437 for (String platform : platforms) { 438 writer.element("platform", platform); 439 } 440 writer.end("platforms"); 441 } 442 if (dependencies != null) { 443 writer.start("dependencies"); 444 writer.startContent(); 445 for (PackageDependency dep : dependencies) { 446 writer.element("package", dep.toString()); 447 } 448 writer.end("dependencies"); 449 } 450 451 if (installer != null) { 452 writer.start("installer"); 453 writer.attr("class", installer.getType()); 454 writer.attr("restart", String.valueOf(installer.getRequireRestart())); 455 writer.end(); 456 } 457 if (uninstaller != null) { 458 writer.start("uninstaller"); 459 writer.attr("class", uninstaller.getType()); 460 writer.attr("restart", String.valueOf(uninstaller.getRequireRestart())); 461 writer.end(); 462 } 463 writer.element("validator", validator); 464 writer.end("package"); 465 } 466 467 @Override 468 public ProductionState getProductionState() { 469 return productionState; 470 } 471 472 @Override 473 public NuxeoValidationState getValidationState() { 474 return validationState; 475 } 476 477 @Override 478 public boolean isSupported() { 479 return supported; 480 } 481 482 @Override 483 public boolean supportsHotReload() { 484 return hotReloadSupport; 485 } 486 487 @Override 488 public void setRequireTermsAndConditionsAcceptance(boolean requireTermsAndConditionsAcceptance) { 489 this.requireTermsAndConditionsAcceptance = requireTermsAndConditionsAcceptance; 490 } 491 492 @Override 493 public boolean requireTermsAndConditionsAcceptance() { 494 return requireTermsAndConditionsAcceptance; 495 } 496 497 @Override 498 public String toXML() { 499 return new XmlSerializer().toXML(this); 500 } 501 502 @Deprecated 503 @Override 504 public int getState() { 505 return PackageState.UNKNOWN.getValue(); 506 } 507 508 @Override 509 public PackageState getPackageState() { 510 return PackageState.UNKNOWN; 511 } 512 513 @Override 514 public boolean isLocal() { 515 throw new UnsupportedOperationException(); 516 } 517 518 @Override 519 public PackageVisibility getVisibility() { 520 return visibility; 521 } 522 523 @Override 524 public void setVisibility(PackageVisibility visibility) { 525 this.visibility = visibility; 526 } 527 528}