| 141 |
141 |
|
| 142 |
142 |
SystemMetadata systemMetadata = null;
|
| 143 |
143 |
try {
|
| 144 |
|
if ( HazelcastService.getInstance().getSystemMetadataMap().containsKey(pid) ) {
|
| 145 |
|
lock = HazelcastService.getInstance().getLock(pid.getValue());
|
| 146 |
|
lock.lock();
|
| 147 |
|
systemMetadata = HazelcastService.getInstance().getSystemMetadataMap().get(pid);
|
|
144 |
lock = HazelcastService.getInstance().getLock(pid.getValue());
|
|
145 |
lock.lock();
|
|
146 |
|
|
147 |
try {
|
|
148 |
if ( HazelcastService.getInstance().getSystemMetadataMap().containsKey(pid) ) {
|
|
149 |
systemMetadata = HazelcastService.getInstance().getSystemMetadataMap().get(pid);
|
|
150 |
|
|
151 |
}
|
|
152 |
|
|
153 |
|
|
154 |
// does the request have the most current system metadata?
|
|
155 |
if ( systemMetadata.getSerialVersion().longValue() != serialVersion ) {
|
|
156 |
String msg = "The requested system metadata version number " +
|
|
157 |
serialVersion + " differs from the current version at " +
|
|
158 |
systemMetadata.getSerialVersion().longValue() +
|
|
159 |
". Please get the latest copy in order to modify it.";
|
|
160 |
throw new InvalidRequest("4883", msg);
|
|
161 |
}
|
| 148 |
162 |
|
|
163 |
} catch (Exception e) { // Catch is generic since HZ throws RuntimeException
|
|
164 |
throw new NotFound("4884", "No record found for: " + pid.getValue());
|
|
165 |
|
| 149 |
166 |
}
|
| 150 |
|
|
| 151 |
|
|
| 152 |
|
// does the request have the most current system metadata?
|
| 153 |
|
if ( systemMetadata.getSerialVersion().longValue() != serialVersion ) {
|
| 154 |
|
String msg = "The requested system metadata version number " +
|
| 155 |
|
serialVersion + " differs from the current version at " +
|
| 156 |
|
systemMetadata.getSerialVersion().longValue() +
|
| 157 |
|
". Please get the latest copy in order to modify it.";
|
| 158 |
|
throw new InvalidRequest("4883", msg);
|
|
167 |
|
|
168 |
// set the new policy
|
|
169 |
systemMetadata.setReplicationPolicy(policy);
|
|
170 |
|
|
171 |
// update the metadata
|
|
172 |
try {
|
|
173 |
systemMetadata.setSerialVersion(systemMetadata.getSerialVersion().add(BigInteger.ONE));
|
|
174 |
systemMetadata.setDateSysMetadataModified(Calendar.getInstance().getTime());
|
|
175 |
HazelcastService.getInstance().getSystemMetadataMap().put(systemMetadata.getIdentifier(), systemMetadata);
|
|
176 |
|
|
177 |
} catch (Exception e) {
|
|
178 |
throw new ServiceFailure("4882", e.getMessage());
|
|
179 |
|
| 159 |
180 |
}
|
| 160 |
181 |
|
| 161 |
|
} catch (Exception e) { // Catch is generic since HZ throws RuntimeException
|
| 162 |
|
throw new NotFound("4884", "No record found for: " + pid.getValue());
|
|
182 |
} catch (Exception e) {
|
|
183 |
throw new ServiceFailure("4882", e.getMessage());
|
| 163 |
184 |
|
| 164 |
|
}
|
| 165 |
|
|
| 166 |
|
// set the new policy
|
| 167 |
|
systemMetadata.setReplicationPolicy(policy);
|
| 168 |
|
|
| 169 |
|
// update the metadata
|
| 170 |
|
try {
|
| 171 |
|
systemMetadata.setSerialVersion(systemMetadata.getSerialVersion().add(BigInteger.ONE));
|
| 172 |
|
systemMetadata.setDateSysMetadataModified(Calendar.getInstance().getTime());
|
| 173 |
|
HazelcastService.getInstance().getSystemMetadataMap().put(systemMetadata.getIdentifier(), systemMetadata);
|
|
185 |
} finally {
|
|
186 |
lock.unlock();
|
|
187 |
logMetacat.debug("Unlocked identifier " + pid.getValue());
|
| 174 |
188 |
|
| 175 |
|
} catch (Exception e) {
|
| 176 |
|
throw new ServiceFailure("4882", e.getMessage());
|
| 177 |
|
|
| 178 |
|
} finally {
|
| 179 |
|
lock.unlock();
|
| 180 |
|
logMetacat.debug("Unlocked identifier " + pid.getValue());
|
| 181 |
|
|
| 182 |
|
|
| 183 |
|
}
|
|
189 |
}
|
| 184 |
190 |
|
| 185 |
191 |
return true;
|
| 186 |
192 |
}
|
| ... | ... | |
| 220 |
226 |
" is " + status.toString());
|
| 221 |
227 |
|
| 222 |
228 |
SystemMetadata systemMetadata = null;
|
| 223 |
|
try {
|
|
229 |
|
|
230 |
try {
|
| 224 |
231 |
lock = HazelcastService.getInstance().getLock(pid.getValue());
|
| 225 |
232 |
lock.lock();
|
| 226 |
|
systemMetadata = HazelcastService.getInstance().getSystemMetadataMap().get(pid);
|
|
233 |
try {
|
|
234 |
systemMetadata = HazelcastService.getInstance().getSystemMetadataMap().get(pid);
|
| 227 |
235 |
|
| 228 |
|
if ( systemMetadata == null ) {
|
| 229 |
|
logMetacat.debug("systemMetadata is null for " + pid.getValue());
|
|
236 |
if ( systemMetadata == null ) {
|
|
237 |
logMetacat.debug("systemMetadata is null for " + pid.getValue());
|
|
238 |
|
|
239 |
}
|
|
240 |
replicas = systemMetadata.getReplicaList();
|
|
241 |
int count = 0;
|
| 230 |
242 |
|
| 231 |
|
}
|
| 232 |
|
replicas = systemMetadata.getReplicaList();
|
| 233 |
|
int count = 0;
|
| 234 |
|
|
| 235 |
|
if ( replicas == null || replicas.size() < 1 ) {
|
| 236 |
|
logMetacat.debug("no replicas to evaluate");
|
| 237 |
|
throw new InvalidRequest("4730", "There are no replicas to update.");
|
|
243 |
if ( replicas == null || replicas.size() < 1 ) {
|
|
244 |
logMetacat.debug("no replicas to evaluate");
|
|
245 |
throw new InvalidRequest("4730", "There are no replicas to update.");
|
|
246 |
|
|
247 |
}
|
|
248 |
|
|
249 |
// find the target replica index in the replica list
|
|
250 |
for (Replica replica: replicas) {
|
|
251 |
String replicaNodeStr = replica.getReplicaMemberNode().getValue();
|
|
252 |
String targetNodeStr = targetNode.getValue();
|
|
253 |
logMetacat.debug("Comparing " + replicaNodeStr + " to " + targetNodeStr);
|
|
254 |
|
|
255 |
if (replicaNodeStr.equals(targetNodeStr)) {
|
|
256 |
replicaEntryIndex = count;
|
|
257 |
logMetacat.debug("replica entry index is: " + replicaEntryIndex);
|
|
258 |
break;
|
|
259 |
}
|
|
260 |
count++;
|
|
261 |
|
|
262 |
}
|
|
263 |
|
|
264 |
// are we allowed to do this? only CNs and target MNs are allowed
|
|
265 |
CNode cn = D1Client.getCN();
|
|
266 |
List<Node> nodes = cn.listNodes().getNodeList();
|
| 238 |
267 |
|
| 239 |
|
}
|
|
268 |
// find the node in the node list
|
|
269 |
for ( Node node : nodes ) {
|
|
270 |
|
|
271 |
NodeReference nodeReference = node.getIdentifier();
|
|
272 |
logMetacat.debug("In setReplicationStatus(), Node reference is: " + nodeReference.getValue());
|
|
273 |
|
|
274 |
// allow target MN certs and CN certs
|
|
275 |
if (targetNode.getValue().equals(nodeReference.getValue()) ||
|
|
276 |
node.getType() == NodeType.CN) {
|
|
277 |
List<Subject> nodeSubjects = node.getSubjectList();
|
|
278 |
|
|
279 |
// check if the session subject is in the node subject list
|
|
280 |
for (Subject nodeSubject : nodeSubjects) {
|
|
281 |
if ( nodeSubject.equals(subject) ) {
|
|
282 |
allowed = true; // subject of session == target node subject
|
|
283 |
break;
|
|
284 |
|
|
285 |
}
|
|
286 |
}
|
|
287 |
}
|
|
288 |
}
|
| 240 |
289 |
|
| 241 |
|
// find the target replica index in the replica list
|
| 242 |
|
for (Replica replica: replicas) {
|
| 243 |
|
String replicaNodeStr = replica.getReplicaMemberNode().getValue();
|
| 244 |
|
String targetNodeStr = targetNode.getValue();
|
| 245 |
|
logMetacat.debug("Comparing " + replicaNodeStr + " to " + targetNodeStr);
|
|
290 |
if ( !allowed ) {
|
|
291 |
String msg = "The subject identified by " + subject.getValue() +
|
|
292 |
" does not have permission to set the replication status for " +
|
|
293 |
"the replica identified by " + targetNode.getValue() + ".";
|
|
294 |
logMetacat.info(msg);
|
|
295 |
throw new NotAuthorized("4720", msg);
|
|
296 |
|
|
297 |
}
|
| 246 |
298 |
|
| 247 |
|
if (replicaNodeStr.equals(targetNodeStr)) {
|
| 248 |
|
replicaEntryIndex = count;
|
| 249 |
|
logMetacat.debug("replica entry index is: " + replicaEntryIndex);
|
| 250 |
|
break;
|
|
299 |
// was there a failure? log it
|
|
300 |
if ( failure != null && status == ReplicationStatus.FAILED ) {
|
|
301 |
String msg = "The replication request of the object identified by " +
|
|
302 |
pid.getValue() + " failed. The error message was " +
|
|
303 |
failure.getMessage() + ".";
|
| 251 |
304 |
}
|
| 252 |
|
count++;
|
| 253 |
305 |
|
|
306 |
} catch (RuntimeException e) { // Catch is generic since HZ throws RuntimeException
|
|
307 |
throw new NotFound("4740", "No record found for: " + pid.getValue() +
|
|
308 |
" : " + e.getMessage());
|
|
309 |
|
| 254 |
310 |
}
|
| 255 |
|
|
| 256 |
|
// are we allowed to do this? only CNs and target MNs are allowed
|
| 257 |
|
CNode cn = D1Client.getCN();
|
| 258 |
|
List<Node> nodes = cn.listNodes().getNodeList();
|
| 259 |
311 |
|
| 260 |
|
// find the node in the node list
|
| 261 |
|
for ( Node node : nodes ) {
|
|
312 |
// set the status for the replica
|
|
313 |
if ( replicaEntryIndex != -1 ) {
|
|
314 |
Replica targetReplica = replicas.get(replicaEntryIndex);
|
|
315 |
targetReplica.setReplicationStatus(status);
|
|
316 |
logMetacat.debug("Set the replication status for " +
|
|
317 |
targetReplica.getReplicaMemberNode().getValue() + " to " +
|
|
318 |
targetReplica.getReplicationStatus());
|
| 262 |
319 |
|
| 263 |
|
NodeReference nodeReference = node.getIdentifier();
|
| 264 |
|
logMetacat.debug("In setReplicationStatus(), Node reference is: " + nodeReference.getValue());
|
| 265 |
|
|
| 266 |
|
// allow target MN certs and CN certs
|
| 267 |
|
if (targetNode.getValue().equals(nodeReference.getValue()) ||
|
| 268 |
|
node.getType() == NodeType.CN) {
|
| 269 |
|
List<Subject> nodeSubjects = node.getSubjectList();
|
| 270 |
|
|
| 271 |
|
// check if the session subject is in the node subject list
|
| 272 |
|
for (Subject nodeSubject : nodeSubjects) {
|
| 273 |
|
if ( nodeSubject.equals(subject) ) {
|
| 274 |
|
allowed = true; // subject of session == target node subject
|
| 275 |
|
break;
|
| 276 |
|
|
| 277 |
|
}
|
| 278 |
|
}
|
| 279 |
|
}
|
| 280 |
|
}
|
|
320 |
} else {
|
|
321 |
throw new InvalidRequest("4730", "There are no replicas to update.");
|
| 281 |
322 |
|
| 282 |
|
if ( !allowed ) {
|
| 283 |
|
String msg = "The subject identified by " + subject.getValue() +
|
| 284 |
|
" does not have permission to set the replication status for " +
|
| 285 |
|
"the replica identified by " + targetNode.getValue() + ".";
|
| 286 |
|
logMetacat.info(msg);
|
| 287 |
|
throw new NotAuthorized("4720", msg);
|
| 288 |
|
|
| 289 |
323 |
}
|
| 290 |
324 |
|
| 291 |
|
// was there a failure? log it
|
| 292 |
|
if ( failure != null && status == ReplicationStatus.FAILED ) {
|
| 293 |
|
String msg = "The replication request of the object identified by " +
|
| 294 |
|
pid.getValue() + " failed. The error message was " +
|
| 295 |
|
failure.getMessage() + ".";
|
|
325 |
systemMetadata.setReplicaList(replicas);
|
|
326 |
|
|
327 |
// update the metadata
|
|
328 |
try {
|
|
329 |
systemMetadata.setSerialVersion(systemMetadata.getSerialVersion().add(BigInteger.ONE));
|
|
330 |
systemMetadata.setDateSysMetadataModified(Calendar.getInstance().getTime());
|
|
331 |
HazelcastService.getInstance().getSystemMetadataMap().put(systemMetadata.getIdentifier(), systemMetadata);
|
|
332 |
|
|
333 |
if ( status == ReplicationStatus.FAILED && failure != null ) {
|
|
334 |
logMetacat.warn("Replication failed for identifier " + pid.getValue() +
|
|
335 |
" on target node " + targetNode + ". The exception was: " +
|
|
336 |
failure.getMessage());
|
|
337 |
}
|
|
338 |
} catch (Exception e) {
|
|
339 |
throw new ServiceFailure("4700", e.getMessage());
|
|
340 |
|
| 296 |
341 |
}
|
| 297 |
342 |
|
| 298 |
|
} catch (RuntimeException e) { // Catch is generic since HZ throws RuntimeException
|
| 299 |
|
throw new NotFound("4740", "No record found for: " + pid.getValue() +
|
| 300 |
|
" : " + e.getMessage());
|
|
343 |
} catch (Exception e) {
|
|
344 |
lock.unlock();
|
|
345 |
logMetacat.debug("Unlocked identifier " + pid.getValue());
|
| 301 |
346 |
|
| 302 |
|
}
|
| 303 |
|
|
| 304 |
|
// set the status for the replica
|
| 305 |
|
if ( replicaEntryIndex != -1 ) {
|
| 306 |
|
Replica targetReplica = replicas.get(replicaEntryIndex);
|
| 307 |
|
targetReplica.setReplicationStatus(status);
|
| 308 |
|
logMetacat.debug("Set the replication status for " +
|
| 309 |
|
targetReplica.getReplicaMemberNode().getValue() + " to " +
|
| 310 |
|
targetReplica.getReplicationStatus());
|
| 311 |
|
|
| 312 |
|
} else {
|
| 313 |
|
throw new InvalidRequest("4730", "There are no replicas to update.");
|
| 314 |
|
|
| 315 |
|
}
|
|
347 |
}
|
| 316 |
348 |
|
| 317 |
|
systemMetadata.setReplicaList(replicas);
|
| 318 |
|
|
| 319 |
|
// update the metadata
|
| 320 |
|
try {
|
| 321 |
|
systemMetadata.setSerialVersion(systemMetadata.getSerialVersion().add(BigInteger.ONE));
|
| 322 |
|
systemMetadata.setDateSysMetadataModified(Calendar.getInstance().getTime());
|
| 323 |
|
HazelcastService.getInstance().getSystemMetadataMap().put(systemMetadata.getIdentifier(), systemMetadata);
|
| 324 |
|
|
| 325 |
|
if ( status == ReplicationStatus.FAILED && failure != null ) {
|
| 326 |
|
logMetacat.warn("Replication failed for identifier " + pid.getValue() +
|
| 327 |
|
" on target node " + targetNode + ". The exception was: " +
|
| 328 |
|
failure.getMessage());
|
| 329 |
|
}
|
| 330 |
|
} catch (Exception e) {
|
| 331 |
|
throw new ServiceFailure("4700", e.getMessage());
|
| 332 |
|
|
| 333 |
|
} finally {
|
| 334 |
|
lock.unlock();
|
| 335 |
|
logMetacat.debug("Unlocked identifier " + pid.getValue());
|
| 336 |
|
|
| 337 |
|
}
|
| 338 |
|
|
| 339 |
349 |
return true;
|
| 340 |
350 |
}
|
| 341 |
351 |
|
| ... | ... | |
| 452 |
462 |
Checksum checksum = null;
|
| 453 |
463 |
|
| 454 |
464 |
try {
|
| 455 |
|
lock = HazelcastService.getInstance().getLock(pid.getValue());
|
| 456 |
|
lock.lock();
|
| 457 |
465 |
systemMetadata = HazelcastService.getInstance().getSystemMetadataMap().get(pid);
|
| 458 |
466 |
checksum = systemMetadata.getChecksum();
|
| 459 |
467 |
|
| ... | ... | |
| 461 |
469 |
throw new ServiceFailure("1410", "An error occurred getting the checksum for " +
|
| 462 |
470 |
pid.getValue() + ". The error message was: " + e.getMessage());
|
| 463 |
471 |
|
| 464 |
|
} finally {
|
| 465 |
|
lock.unlock();
|
| 466 |
|
logMetacat.debug("Unlocked identifier " + pid.getValue());
|
| 467 |
|
|
| 468 |
472 |
}
|
| 469 |
473 |
|
| 470 |
474 |
return checksum;
|
| ... | ... | |
| 819 |
823 |
SystemMetadata systemMetadata = null;
|
| 820 |
824 |
try {
|
| 821 |
825 |
lock = HazelcastService.getInstance().getLock(pid.getValue());
|
| 822 |
|
systemMetadata = HazelcastService.getInstance().getSystemMetadataMap().get(pid);
|
| 823 |
826 |
|
| 824 |
|
// does the request have the most current system metadata?
|
| 825 |
|
if ( systemMetadata.getSerialVersion().longValue() != serialVersion ) {
|
| 826 |
|
String msg = "The requested system metadata version number " +
|
| 827 |
|
serialVersion + " differs from the current version at " +
|
| 828 |
|
systemMetadata.getSerialVersion().longValue() +
|
| 829 |
|
". Please get the latest copy in order to modify it.";
|
| 830 |
|
throw new InvalidRequest("4442", msg);
|
|
827 |
try {
|
|
828 |
systemMetadata = HazelcastService.getInstance().getSystemMetadataMap().get(pid);
|
|
829 |
|
|
830 |
// does the request have the most current system metadata?
|
|
831 |
if ( systemMetadata.getSerialVersion().longValue() != serialVersion ) {
|
|
832 |
String msg = "The requested system metadata version number " +
|
|
833 |
serialVersion + " differs from the current version at " +
|
|
834 |
systemMetadata.getSerialVersion().longValue() +
|
|
835 |
". Please get the latest copy in order to modify it.";
|
|
836 |
throw new InvalidRequest("4442", msg);
|
|
837 |
}
|
|
838 |
|
|
839 |
} catch (Exception e) { // Catch is generic since HZ throws RuntimeException
|
|
840 |
throw new NotFound("4460", "No record found for: " + pid.getValue());
|
|
841 |
|
| 831 |
842 |
}
|
|
843 |
|
|
844 |
// set the new rights holder
|
|
845 |
systemMetadata.setRightsHolder(userId);
|
| 832 |
846 |
|
| 833 |
|
} catch (Exception e) { // Catch is generic since HZ throws RuntimeException
|
| 834 |
|
throw new NotFound("4460", "No record found for: " + pid.getValue());
|
|
847 |
// update the metadata
|
|
848 |
try {
|
|
849 |
systemMetadata.setSerialVersion(systemMetadata.getSerialVersion().add(BigInteger.ONE));
|
|
850 |
systemMetadata.setDateSysMetadataModified(Calendar.getInstance().getTime());
|
|
851 |
HazelcastService.getInstance().getSystemMetadataMap().put(pid, systemMetadata);
|
|
852 |
|
|
853 |
} catch (Exception e) {
|
|
854 |
throw new ServiceFailure("4490", e.getMessage());
|
| 835 |
855 |
|
| 836 |
|
}
|
|
856 |
}
|
| 837 |
857 |
|
| 838 |
|
// set the new rights holder
|
| 839 |
|
systemMetadata.setRightsHolder(userId);
|
| 840 |
|
|
| 841 |
|
// update the metadata
|
| 842 |
|
try {
|
| 843 |
|
systemMetadata.setSerialVersion(systemMetadata.getSerialVersion().add(BigInteger.ONE));
|
| 844 |
|
systemMetadata.setDateSysMetadataModified(Calendar.getInstance().getTime());
|
| 845 |
|
HazelcastService.getInstance().getSystemMetadataMap().put(pid, systemMetadata);
|
|
858 |
} catch (Exception e) {
|
|
859 |
throw new ServiceFailure("4490", e.getMessage());
|
| 846 |
860 |
|
| 847 |
|
} catch (Exception e) {
|
| 848 |
|
throw new ServiceFailure("4490", e.getMessage());
|
| 849 |
|
|
| 850 |
861 |
} finally {
|
| 851 |
862 |
lock.unlock();
|
| 852 |
863 |
logMetacat.debug("Unlocked identifier " + pid.getValue());
|
| 853 |
|
|
|
864 |
|
| 854 |
865 |
}
|
| 855 |
866 |
|
| 856 |
|
return pid;
|
|
867 |
return pid;
|
| 857 |
868 |
}
|
| 858 |
869 |
|
| 859 |
870 |
/**
|
| ... | ... | |
| 1102 |
1113 |
try {
|
| 1103 |
1114 |
lock = HazelcastService.getInstance().getLock(pid.getValue());
|
| 1104 |
1115 |
lock.lock();
|
| 1105 |
|
systemMetadata = HazelcastService.getInstance().getSystemMetadataMap().get(pid);
|
|
1116 |
|
|
1117 |
try {
|
|
1118 |
systemMetadata = HazelcastService.getInstance().getSystemMetadataMap().get(pid);
|
| 1106 |
1119 |
|
| 1107 |
|
// does the request have the most current system metadata?
|
| 1108 |
|
if ( systemMetadata.getSerialVersion().longValue() != serialVersion ) {
|
| 1109 |
|
String msg = "The requested system metadata version number " +
|
| 1110 |
|
serialVersion + " differs from the current version at " +
|
| 1111 |
|
systemMetadata.getSerialVersion().longValue() +
|
| 1112 |
|
". Please get the latest copy in order to modify it.";
|
| 1113 |
|
throw new InvalidRequest("4402", msg);
|
|
1120 |
// does the request have the most current system metadata?
|
|
1121 |
if ( systemMetadata.getSerialVersion().longValue() != serialVersion ) {
|
|
1122 |
String msg = "The requested system metadata version number " +
|
|
1123 |
serialVersion + " differs from the current version at " +
|
|
1124 |
systemMetadata.getSerialVersion().longValue() +
|
|
1125 |
". Please get the latest copy in order to modify it.";
|
|
1126 |
throw new InvalidRequest("4402", msg);
|
|
1127 |
}
|
|
1128 |
|
|
1129 |
} catch (Exception e) {
|
|
1130 |
// convert Hazelcast RuntimeException to NotFound
|
|
1131 |
throw new NotFound("4400", "No record found for: " + pid);
|
|
1132 |
|
| 1114 |
1133 |
}
|
|
1134 |
|
|
1135 |
// set the access policy
|
|
1136 |
systemMetadata.setAccessPolicy(accessPolicy);
|
| 1115 |
1137 |
|
| 1116 |
|
} catch (Exception e) {
|
| 1117 |
|
// convert Hazelcast RuntimeException to NotFound
|
| 1118 |
|
throw new NotFound("4400", "No record found for: " + pid);
|
| 1119 |
|
|
| 1120 |
|
}
|
|
1138 |
// update the system metadata
|
|
1139 |
try {
|
|
1140 |
systemMetadata.setSerialVersion(systemMetadata.getSerialVersion().add(BigInteger.ONE));
|
|
1141 |
systemMetadata.setDateSysMetadataModified(Calendar.getInstance().getTime());
|
|
1142 |
HazelcastService.getInstance().getSystemMetadataMap().put(systemMetadata.getIdentifier(), systemMetadata);
|
|
1143 |
|
|
1144 |
} catch (Exception e) {
|
|
1145 |
// convert Hazelcast RuntimeException to ServiceFailure
|
|
1146 |
throw new ServiceFailure("4430", e.getMessage());
|
|
1147 |
|
|
1148 |
}
|
| 1121 |
1149 |
|
| 1122 |
|
// set the access policy
|
| 1123 |
|
systemMetadata.setAccessPolicy(accessPolicy);
|
| 1124 |
|
|
| 1125 |
|
// update the system metadata
|
| 1126 |
|
try {
|
| 1127 |
|
systemMetadata.setSerialVersion(systemMetadata.getSerialVersion().add(BigInteger.ONE));
|
| 1128 |
|
systemMetadata.setDateSysMetadataModified(Calendar.getInstance().getTime());
|
| 1129 |
|
HazelcastService.getInstance().getSystemMetadataMap().put(systemMetadata.getIdentifier(), systemMetadata);
|
| 1130 |
|
|
| 1131 |
1150 |
} catch (Exception e) {
|
| 1132 |
|
// convert Hazelcast RuntimeException to ServiceFailure
|
| 1133 |
1151 |
throw new ServiceFailure("4430", e.getMessage());
|
| 1134 |
|
|
|
1152 |
|
| 1135 |
1153 |
} finally {
|
| 1136 |
1154 |
lock.unlock();
|
| 1137 |
1155 |
logMetacat.debug("Unlocked identifier " + pid.getValue());
|
| 1138 |
1156 |
|
| 1139 |
1157 |
}
|
|
1158 |
|
| 1140 |
1159 |
|
| 1141 |
1160 |
// TODO: how do we know if the map was persisted?
|
| 1142 |
1161 |
success = true;
|
| ... | ... | |
| 1184 |
1203 |
}
|
| 1185 |
1204 |
|
| 1186 |
1205 |
SystemMetadata systemMetadata = null;
|
| 1187 |
|
try {
|
|
1206 |
try {
|
| 1188 |
1207 |
lock = HazelcastService.getInstance().getLock(pid.getValue());
|
| 1189 |
1208 |
lock.lock();
|
| 1190 |
|
systemMetadata = HazelcastService.getInstance().getSystemMetadataMap().get(pid);
|
| 1191 |
1209 |
|
| 1192 |
|
// does the request have the most current system metadata?
|
| 1193 |
|
if ( systemMetadata.getSerialVersion().longValue() != serialVersion ) {
|
| 1194 |
|
String msg = "The requested system metadata version number " +
|
| 1195 |
|
serialVersion + " differs from the current version at " +
|
| 1196 |
|
systemMetadata.getSerialVersion().longValue() +
|
| 1197 |
|
". Please get the latest copy in order to modify it.";
|
| 1198 |
|
throw new InvalidRequest("4853", msg);
|
|
1210 |
try {
|
|
1211 |
systemMetadata = HazelcastService.getInstance().getSystemMetadataMap().get(pid);
|
|
1212 |
|
|
1213 |
// does the request have the most current system metadata?
|
|
1214 |
if ( systemMetadata.getSerialVersion().longValue() != serialVersion ) {
|
|
1215 |
String msg = "The requested system metadata version number " +
|
|
1216 |
serialVersion + " differs from the current version at " +
|
|
1217 |
systemMetadata.getSerialVersion().longValue() +
|
|
1218 |
". Please get the latest copy in order to modify it.";
|
|
1219 |
throw new InvalidRequest("4853", msg);
|
|
1220 |
}
|
|
1221 |
|
|
1222 |
} catch (Exception e) { // Catch is generic since HZ throws RuntimeException
|
|
1223 |
throw new NotFound("4854", "No record found for: " + pid.getValue() +
|
|
1224 |
" : " + e.getMessage());
|
|
1225 |
|
| 1199 |
1226 |
}
|
|
1227 |
|
|
1228 |
// set the status for the replica
|
|
1229 |
List<Replica> replicas = systemMetadata.getReplicaList();
|
|
1230 |
NodeReference replicaNode = replica.getReplicaMemberNode();
|
|
1231 |
int index = 0;
|
|
1232 |
for (Replica listedReplica: replicas) {
|
|
1233 |
|
|
1234 |
// remove the replica that we are replacing
|
|
1235 |
if ( replicaNode.getValue().equals(listedReplica.getReplicaMemberNode().getValue())) {
|
|
1236 |
replicas.remove(index);
|
|
1237 |
break;
|
|
1238 |
|
|
1239 |
}
|
|
1240 |
index++;
|
|
1241 |
}
|
| 1200 |
1242 |
|
| 1201 |
|
} catch (Exception e) { // Catch is generic since HZ throws RuntimeException
|
| 1202 |
|
throw new NotFound("4854", "No record found for: " + pid.getValue() +
|
| 1203 |
|
" : " + e.getMessage());
|
| 1204 |
|
|
| 1205 |
|
}
|
|
1243 |
// add the new replica item
|
|
1244 |
replicas.add(replica);
|
|
1245 |
systemMetadata.setReplicaList(replicas);
|
| 1206 |
1246 |
|
| 1207 |
|
// set the status for the replica
|
| 1208 |
|
List<Replica> replicas = systemMetadata.getReplicaList();
|
| 1209 |
|
NodeReference replicaNode = replica.getReplicaMemberNode();
|
| 1210 |
|
int index = 0;
|
| 1211 |
|
for (Replica listedReplica: replicas) {
|
|
1247 |
// update the metadata
|
|
1248 |
try {
|
|
1249 |
systemMetadata.setSerialVersion(systemMetadata.getSerialVersion().add(BigInteger.ONE));
|
|
1250 |
systemMetadata.setDateSysMetadataModified(Calendar.getInstance().getTime());
|
|
1251 |
HazelcastService.getInstance().getSystemMetadataMap().put(systemMetadata.getIdentifier(), systemMetadata);
|
|
1252 |
|
|
1253 |
} catch (Exception e) {
|
|
1254 |
throw new ServiceFailure("4852", e.getMessage());
|
| 1212 |
1255 |
|
| 1213 |
|
// remove the replica that we are replacing
|
| 1214 |
|
if ( replicaNode.getValue().equals(listedReplica.getReplicaMemberNode().getValue())) {
|
| 1215 |
|
replicas.remove(index);
|
| 1216 |
|
break;
|
| 1217 |
|
|
| 1218 |
1256 |
}
|
| 1219 |
|
index++;
|
| 1220 |
|
}
|
| 1221 |
|
|
| 1222 |
|
// add the new replica item
|
| 1223 |
|
replicas.add(replica);
|
| 1224 |
|
systemMetadata.setReplicaList(replicas);
|
| 1225 |
|
|
| 1226 |
|
// update the metadata
|
| 1227 |
|
try {
|
| 1228 |
|
systemMetadata.setSerialVersion(systemMetadata.getSerialVersion().add(BigInteger.ONE));
|
| 1229 |
|
systemMetadata.setDateSysMetadataModified(Calendar.getInstance().getTime());
|
| 1230 |
|
HazelcastService.getInstance().getSystemMetadataMap().put(systemMetadata.getIdentifier(), systemMetadata);
|
|
1257 |
|
|
1258 |
} catch (Exception e) {
|
|
1259 |
throw new ServiceFailure("4852", e.getMessage());
|
|
1260 |
|
|
1261 |
} finally {
|
|
1262 |
lock.unlock();
|
|
1263 |
logMetacat.debug("Unlocked identifier " + pid.getValue());
|
| 1231 |
1264 |
|
| 1232 |
|
} catch (Exception e) {
|
| 1233 |
|
throw new ServiceFailure("4852", e.getMessage());
|
| 1234 |
|
|
| 1235 |
|
} finally {
|
| 1236 |
|
lock.unlock();
|
| 1237 |
|
logMetacat.debug("Unlocked identifier " + pid.getValue());
|
| 1238 |
|
|
| 1239 |
|
}
|
|
1265 |
}
|
| 1240 |
1266 |
|
| 1241 |
1267 |
return true;
|
| 1242 |
1268 |
|
| 1243 |
1269 |
}
|
| 1244 |
1270 |
|
| 1245 |
1271 |
@Override
|
| 1246 |
|
public ObjectList listObjects(Session session, Date startTime,
|
| 1247 |
|
Date endTime, ObjectFormatIdentifier formatid, Boolean replicaStatus,
|
| 1248 |
|
Integer start, Integer count)
|
|
1272 |
public ObjectList listObjects(Session session, Date startTime,
|
|
1273 |
Date endTime, ObjectFormatIdentifier formatid, Boolean replicaStatus,
|
|
1274 |
Integer start, Integer count)
|
| 1249 |
1275 |
throws InvalidRequest, InvalidToken, NotAuthorized, NotImplemented,
|
| 1250 |
1276 |
ServiceFailure {
|
| 1251 |
1277 |
|
After reviewing CNodeService and D1NodeService prompted by Robert comparing the Hazelcast locking with the d1_synchronization locking, I've made a number of changes that will prevent locking problems:
1) Multiple methods contained try/catch blocks that would:
try
lock();
catch
throw();
try
put();
catch
throw();
finally
unlock();
So the lock obtained in the first try catch would never unlock if an exception is thrown. This is fixed by using an outer try/catch/finally block for locking and unlocking to ensure the lock is released.
2) In some cases we need to lock() prior to a get() from the hzSystemMetadata, other times we don't when there's no put() subsequently involved (like getChecksum(), get(), etc.) Remove any locking in those cases.