1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
|
/*******************************************************************************
* Copyright (c) 2004, 2016 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.osgi.internal.location;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.atomic.AtomicBoolean;
import org.eclipse.osgi.framework.log.FrameworkLogEntry;
import org.eclipse.osgi.internal.framework.EquinoxConfiguration.ConfigValues;
import org.eclipse.osgi.internal.framework.EquinoxContainer;
import org.eclipse.osgi.internal.log.EquinoxLogServices;
import org.eclipse.osgi.internal.messages.Msg;
import org.eclipse.osgi.service.datalocation.Location;
import org.eclipse.osgi.util.NLS;
/**
* Internal class.
*/
public class BasicLocation implements Location {
private static String DEFAULT_LOCK_FILENAME = ".metadata/.lock"; //$NON-NLS-1$
final private boolean isReadOnly;
final private URL defaultValue;
final private String property;
final private String dataAreaPrefix;
final private ConfigValues configValues;
final private AtomicBoolean debug;
final private EquinoxContainer container;
private URL location = null;
private Location parent;
// locking related fields
private File lockFile;
private Locker locker;
public BasicLocation(String property, URL defaultValue, boolean isReadOnly, String dataAreaPrefix, ConfigValues configValues, EquinoxContainer container, AtomicBoolean debug) {
this.property = property;
this.defaultValue = defaultValue;
this.isReadOnly = isReadOnly;
// make sure the prefix ends with '/' if it is not empty/null
String tempDataAreaPrefix = dataAreaPrefix == null ? "" : dataAreaPrefix; //$NON-NLS-1$
tempDataAreaPrefix = tempDataAreaPrefix.replace('\\', '/');
if (tempDataAreaPrefix.length() > 0 && tempDataAreaPrefix.charAt(tempDataAreaPrefix.length() - 1) != '/') {
tempDataAreaPrefix += '/';
}
this.dataAreaPrefix = tempDataAreaPrefix;
this.configValues = configValues;
this.container = container;
this.debug = debug;
}
public boolean allowsDefault() {
return defaultValue != null;
}
public URL getDefault() {
return defaultValue;
}
public synchronized Location getParentLocation() {
return parent;
}
public synchronized URL getURL() {
if (location == null && defaultValue != null) {
if (debug.get()) {
EquinoxLogServices logServices = container.getLogServices();
// Note that logServices can be null if we are very early in the startup.
if (logServices != null) {
logServices.log(EquinoxContainer.NAME, FrameworkLogEntry.INFO, "Called Location.getURL() when it has not been set for: \"" + property + "\"", new RuntimeException("Call stack for Location.getURL()")); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
}
}
setURL(defaultValue, false);
}
return location;
}
public synchronized boolean isSet() {
return location != null;
}
public boolean isReadOnly() {
return isReadOnly;
}
/**
* @deprecated
*/
public boolean setURL(URL value, boolean lock) throws IllegalStateException {
try {
return set(value, lock);
} catch (IOException e) {
return false;
}
}
public synchronized boolean set(URL value, boolean lock) throws IllegalStateException, IOException {
return set(value, lock, null);
}
public synchronized boolean set(URL value, boolean lock, String lockFilePath) throws IllegalStateException, IOException {
if (location != null)
throw new IllegalStateException(Msg.ECLIPSE_CANNOT_CHANGE_LOCATION);
File file = null;
if (value.getProtocol().equalsIgnoreCase("file")) { //$NON-NLS-1$
try {
File f = LocationHelper.decodePath(new File(value.getPath()));
String basePath = f.getCanonicalPath();
value = LocationHelper.buildURL("file:" + basePath, true); //$NON-NLS-1$
} catch (IOException e) {
// do nothing just use the original value
}
if (lockFilePath != null && lockFilePath.length() > 0) {
File givenLockFile = new File(lockFilePath);
if (givenLockFile.isAbsolute()) {
file = givenLockFile;
} else {
file = new File(value.getPath(), lockFilePath);
}
} else {
file = new File(value.getPath(), DEFAULT_LOCK_FILENAME);
}
}
lock = lock && !isReadOnly;
if (lock) {
if (!lock(file, value))
return false;
}
lockFile = file;
location = value;
if (property != null)
configValues.setConfiguration(property, location.toExternalForm());
return lock;
}
public synchronized void setParent(Location value) {
parent = value;
}
public synchronized boolean lock() throws IOException {
if (!isSet())
throw new IOException(Msg.location_notSet);
return lock(lockFile, location);
}
public synchronized boolean isLocked() throws IOException {
if (!isSet())
return false;
return isLocked(lockFile);
}
/*
* This must be called while holding the synchronization lock for (this)
*/
private boolean lock(File lock, URL locationValue) throws IOException {
if (isReadOnly)
throw new IOException(NLS.bind(Msg.location_folderReadOnly, lock));
if (lock == null) {
if (locationValue != null && !"file".equalsIgnoreCase(locationValue.getProtocol())) //$NON-NLS-1$
throw new IOException(NLS.bind(Msg.location_notFileProtocol, locationValue));
throw new IllegalStateException(Msg.location_noLockFile); // this is really unexpected
}
if (isLocked())
return false;
File parentFile = new File(lock.getParent());
if (!parentFile.isDirectory()) {
parentFile.mkdirs();
if (!parentFile.isDirectory())
throw new IOException(NLS.bind(Msg.location_folderReadOnly, parentFile));
}
setLocker(lock);
if (locker == null)
return true;
boolean locked = false;
try {
locked = locker.lock();
return locked;
} finally {
if (!locked)
locker = null;
}
}
/*
* This must be called while holding the synchronization lock for (this)
*/
private boolean isLocked(File lock) throws IOException {
if (lock == null || isReadOnly)
return true;
if (!lock.exists())
return false;
setLocker(lock);
return locker.isLocked();
}
/*
* This must be called while holding the synchronization lock for (this)
*/
private void setLocker(File lock) {
if (locker != null)
return;
String lockMode = configValues.getConfiguration(LocationHelper.PROP_OSGI_LOCKING, LocationHelper.LOCKING_NIO);
locker = LocationHelper.createLocker(lock, lockMode, debug.get());
}
public synchronized void release() {
if (locker != null)
locker.release();
}
public Location createLocation(Location parentLocation, URL defaultLocation, boolean readonly) {
BasicLocation result = new BasicLocation(null, defaultLocation, readonly, dataAreaPrefix, configValues, container, debug);
result.setParent(parentLocation);
return result;
}
public URL getDataArea(String filename) throws IOException {
URL base = getURL();
if (base == null)
throw new IOException(Msg.location_notSet);
String prefix = base.toExternalForm();
if (prefix.length() > 0 && prefix.charAt(prefix.length() - 1) != '/')
prefix += '/';
filename = filename.replace('\\', '/');
if (filename.length() > 0 && filename.charAt(0) == '/')
filename = filename.substring(1);
String spec = prefix + dataAreaPrefix + filename;
boolean trailingSlash = spec.length() > 0 && spec.charAt(spec.length() - 1) == '/';
return LocationHelper.buildURL(spec, trailingSlash);
}
}
|
