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