001/* 002 * (C) Copyright 2006-2015 Nuxeo SA (http://nuxeo.com/) and contributors. 003 * 004 * All rights reserved. This program and the accompanying materials 005 * are made available under the terms of the GNU Lesser General Public License 006 * (LGPL) version 2.1 which accompanies this distribution, and is available at 007 * http://www.gnu.org/licenses/lgpl-2.1 008 * Lesser General Public License for more details. 009 * 010 * Contributors: 011 * bstefanescu 012 */ 013package org.nuxeo.connect.update.task.update; 014 015import java.util.ArrayList; 016import java.util.Iterator; 017import java.util.List; 018 019import org.nuxeo.common.utils.FileVersion; 020 021/** 022 * Versions are stored in the same order they are registered (in historical package install order). That means when 023 * rollbacking an update the file system will be modified only if the last version was rollbacked. And the version that 024 * will become the current version will be the last version in the version list. 025 * 026 * @author <a href="mailto:bs@nuxeo.com">Bogdan Stefanescu</a> 027 */ 028public class Entry implements Iterable<Version> { 029 030 protected String key; 031 032 protected Version baseVersion; 033 034 protected List<Version> versions; 035 036 public Entry(String key) { 037 this.key = key; 038 versions = new ArrayList<Version>(); 039 } 040 041 public final boolean isEmpty() { 042 return versions.isEmpty(); 043 } 044 045 public final Version getFirstVersion() { 046 return versions.isEmpty() ? null : versions.get(0); 047 } 048 049 public final Version getLastVersion() { 050 return versions.isEmpty() ? null : versions.get(versions.size() - 1); 051 } 052 053 /** 054 * @param includeUpgradeOnly 055 * @return Last version not deployed in upgradeOnly mode 056 * @since 5.7 057 */ 058 public Version getLastVersion(boolean includeUpgradeOnly) { 059 if (includeUpgradeOnly) { 060 return getLastVersion(); 061 } 062 for (int i = versions.size() - 1; i >= 0; i--) { 063 for (UpdateOptions opt : versions.get(i).packages.values()) { 064 if (opt.upgradeOnly == false) { 065 return versions.get(i); 066 } 067 } 068 } 069 return null; 070 } 071 072 public final String getKey() { 073 return key; 074 } 075 076 public final void setBaseVersion(Version baseVersion) { 077 this.baseVersion = baseVersion; 078 } 079 080 public final boolean hasBaseVersion() { 081 return baseVersion != null; 082 } 083 084 public final Version getBaseVersion() { 085 return baseVersion; 086 } 087 088 public final boolean isLastVersion(Version v) { 089 return v == getLastVersion(); 090 } 091 092 public boolean removeVersion(Version version) { 093 return versions.remove(version); 094 } 095 096 public Version addVersion(Version version) { 097 if (versions.contains(version)) { 098 throw new VersionAlreadyExistException(version.getVersion()); 099 } 100 versions.add(version); 101 return version; 102 } 103 104 public Version getVersion(String version) { 105 for (Version v : versions) { 106 String ov = v.getVersion(); 107 if ((ov != null && ov.equals(version)) || (ov == null && version == null)) { 108 return v; 109 } 110 } 111 return null; 112 } 113 114 public Version getGreatestVersion() { 115 Version result = null; 116 FileVersion fv = null; 117 for (Version v : versions) { 118 if (fv == null) { 119 fv = v.getFileVersion(); 120 result = v; 121 } else { 122 FileVersion fv2 = v.getFileVersion(); 123 if (fv.lessThan(fv2)) { 124 result = v; 125 fv = fv2; 126 } 127 } 128 } 129 return result; 130 } 131 132 /** 133 * @param version 134 */ 135 public Version getOrCreateVersion(String version) { 136 Version v = getVersion(version); 137 if (v == null) { 138 return addVersion(new Version(version)); 139 } 140 return v; 141 } 142 143 public List<Version> getVersions() { 144 return versions; 145 } 146 147 @Override 148 public Iterator<Version> iterator() { 149 return versions.iterator(); 150 } 151 152 @Override 153 public String toString() { 154 return key; 155 } 156 157}