2 * ============LICENSE_START==========================================
4 * ===================================================================
5 * Copyright (c) 2017 AT&T Intellectual Property
6 * ===================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
19 * ============LICENSE_END=============================================
20 * ====================================================================
23 package org.onap.music.rest;
27 import javax.ws.rs.Consumes;
28 import javax.ws.rs.DELETE;
29 import javax.ws.rs.GET;
30 import javax.ws.rs.HeaderParam;
31 import javax.ws.rs.POST;
32 import javax.ws.rs.Path;
33 import javax.ws.rs.PathParam;
34 import javax.ws.rs.Produces;
35 import javax.ws.rs.core.MediaType;
36 import javax.ws.rs.core.Response;
37 import javax.ws.rs.core.Response.ResponseBuilder;
38 import javax.ws.rs.core.Response.Status;
40 import org.onap.music.authentication.MusicAuthentication;
41 import org.onap.music.datastore.jsonobjects.JsonLeasedLock;
42 import org.onap.music.eelf.logging.EELFLoggerDelegate;
43 import org.onap.music.eelf.logging.format.AppMessages;
44 import org.onap.music.eelf.logging.format.ErrorSeverity;
45 import org.onap.music.eelf.logging.format.ErrorTypes;
46 import org.onap.music.lockingservice.cassandra.MusicLockState;
47 import org.onap.music.main.MusicCore;
48 import org.onap.music.main.MusicUtil;
49 import org.onap.music.main.ResultType;
50 import org.onap.music.main.ReturnType;
51 import org.onap.music.response.jsonobjects.JsonResponse;
53 import io.swagger.annotations.Api;
54 import io.swagger.annotations.ApiOperation;
55 import io.swagger.annotations.ApiParam;
59 @Api(value="Lock Api")
60 public class RestMusicLocksAPI {
62 private EELFLoggerDelegate logger =EELFLoggerDelegate.getLogger(RestMusicLocksAPI.class);
63 private static final String XMINORVERSION = "X-minorVersion";
64 private static final String XPATCHVERSION = "X-patchVersion";
65 private static final String VERSION = "v2";
68 * Puts the requesting process in the q for this lock. The corresponding
69 * node will be created in zookeeper if it did not already exist
76 @Path("/create/{lockname}")
77 @ApiOperation(value = "Create Lock",
78 notes = "Puts the requesting process in the q for this lock." +
79 " The corresponding node will be created in zookeeper if it did not already exist." +
80 " Lock Name is the \"key\" of the form keyspaceName.tableName.rowId",
82 @Produces(MediaType.APPLICATION_JSON)
83 public Response createLockReference(
84 @ApiParam(value="Lock Name",required=true) @PathParam("lockname") String lockName,
85 @ApiParam(value = "Minor Version",required = false) @HeaderParam(XMINORVERSION) String minorVersion,
86 @ApiParam(value = "Patch Version",required = false) @HeaderParam(XPATCHVERSION) String patchVersion,
87 @ApiParam(value = "Authorization", required = true) @HeaderParam(MusicUtil.AUTHORIZATION) String authorization,
88 @ApiParam(value = "AID", required = true) @HeaderParam("aid") String aid,
89 @ApiParam(value = "Application namespace",
90 required = true) @HeaderParam("ns") String ns) throws Exception{
92 ResponseBuilder response = MusicUtil.buildVersionResponse(VERSION, minorVersion, patchVersion);
93 Map<String, Object> resultMap = MusicCore.validateLock(lockName);
94 if (resultMap.containsKey("Error")) {
95 logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.MISSINGINFO ,ErrorSeverity.CRITICAL, ErrorTypes.GENERALSERVICEERROR);
96 response.status(Status.BAD_REQUEST);
97 return response.entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(resultMap.get("Error"))).toMap()).build();
99 Map<String,String> userCredentials = MusicUtil.extractBasicAuthentication(authorization);
100 String userId = userCredentials.get(MusicUtil.USERID);
101 String password = userCredentials.get(MusicUtil.PASSWORD);
102 String keyspaceName = (String) resultMap.get("keyspace");
103 EELFLoggerDelegate.mdcPut("keyspace", "( "+keyspaceName+" ) ");
104 resultMap.remove("keyspace");
105 resultMap = MusicAuthentication.autheticateUser(ns, userId, password, keyspaceName, aid,
106 "createLockReference");
107 if (resultMap.containsKey("aid"))
108 resultMap.remove("aid");
109 if (!resultMap.isEmpty()) {
110 logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.MISSINGDATA ,ErrorSeverity.CRITICAL, ErrorTypes.AUTHENTICATIONERROR);
111 response.status(Status.UNAUTHORIZED);
112 return response.entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(resultMap.get("Error"))).toMap()).build();
114 ResultType status = ResultType.SUCCESS;
115 String lockId = MusicCore.createLockReference(lockName);
117 if (lockId == null) {
118 status = ResultType.FAILURE;
119 logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.LOCKINGERROR ,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
120 return response.status(Status.BAD_REQUEST).entity(new JsonResponse(status).setError("Lock Id is null").toMap()).build();
122 return response.status(Status.OK).entity(new JsonResponse(status).setLock(lockId).toMap()).build();
124 EELFLoggerDelegate.mdcRemove("keyspace");
130 * Checks if the node is in the top of the queue and hence acquires the lock
137 @Path("/acquire/{lockreference}")
138 @ApiOperation(value = "Aquire Lock",
139 notes = "Checks if the node is in the top of the queue and hence acquires the lock",
140 response = Map.class)
141 @Produces(MediaType.APPLICATION_JSON)
142 public Response accquireLock(
143 @ApiParam(value="Lock Reference",required=true) @PathParam("lockreference") String lockId,
144 @ApiParam(value = "Minor Version",required = false) @HeaderParam(XMINORVERSION) String minorVersion,
145 @ApiParam(value = "Patch Version",required = false) @HeaderParam(XPATCHVERSION) String patchVersion,
146 @ApiParam(value = "Authorization", required = true) @HeaderParam(MusicUtil.AUTHORIZATION) String authorization,
147 @ApiParam(value = "AID", required = true) @HeaderParam("aid") String aid,
148 @ApiParam(value = "Application namespace",
149 required = true) @HeaderParam("ns") String ns) throws Exception{
151 ResponseBuilder response = MusicUtil.buildVersionResponse(VERSION, minorVersion, patchVersion);
152 Map<String, Object> resultMap = MusicCore.validateLock(lockId);
153 if (resultMap.containsKey("Error")) {
154 logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.INCORRECTDATA ,ErrorSeverity.CRITICAL, ErrorTypes.GENERALSERVICEERROR);
155 response.status(Status.BAD_REQUEST);
156 return response.entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(resultMap.get("Error"))).toMap()).build();
158 Map<String,String> userCredentials = MusicUtil.extractBasicAuthentication(authorization);
159 String userId = userCredentials.get(MusicUtil.USERID);
160 String password = userCredentials.get(MusicUtil.PASSWORD);
161 String keyspaceName = (String) resultMap.get("keyspace");
162 EELFLoggerDelegate.mdcPut("keyspace", "( "+keyspaceName+" ) ");
163 resultMap.remove("keyspace");
164 resultMap = MusicAuthentication.autheticateUser(ns, userId, password, keyspaceName, aid,
166 if (resultMap.containsKey("aid"))
167 resultMap.remove("aid");
168 if (!resultMap.isEmpty()) {
169 logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.MISSINGDATA ,ErrorSeverity.CRITICAL, ErrorTypes.AUTHENTICATIONERROR);
170 response.status(Status.UNAUTHORIZED);
171 return response.entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(resultMap.get("Error"))).toMap()).build();
174 String lockName = lockId.substring(lockId.indexOf('$')+1, lockId.lastIndexOf('$'));
175 ReturnType lockStatus = MusicCore.acquireLock(lockName,lockId);
176 if ( lockStatus.getResult().equals(ResultType.SUCCESS)) {
177 response.status(Status.OK);
179 response.status(Status.BAD_REQUEST);
181 return response.entity(new JsonResponse(lockStatus.getResult()).setLock(lockId).setMessage(lockStatus.getMessage()).toMap()).build();
182 } catch (Exception e) {
183 logger.error(EELFLoggerDelegate.errorLogger,AppMessages.INVALIDLOCK + lockId, ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
184 return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError("Unable to aquire lock").toMap()).build();
187 EELFLoggerDelegate.mdcRemove("keyspace");
195 @Path("/acquire-with-lease/{lockreference}")
196 @ApiOperation(value = "Aquire Lock with Lease", response = Map.class)
197 @Consumes(MediaType.APPLICATION_JSON)
198 @Produces(MediaType.APPLICATION_JSON)
199 public Response accquireLockWithLease(JsonLeasedLock lockObj,
200 @ApiParam(value="Lock Reference",required=true) @PathParam("lockreference") String lockId,
201 @ApiParam(value = "Minor Version",required = false) @HeaderParam(XMINORVERSION) String minorVersion,
202 @ApiParam(value = "Patch Version",required = false) @HeaderParam(XPATCHVERSION) String patchVersion,
203 @ApiParam(value = "Authorization", required = true) @HeaderParam(MusicUtil.AUTHORIZATION) String authorization,
204 @ApiParam(value = "AID", required = true) @HeaderParam("aid") String aid,
205 @ApiParam(value = "Application namespace",
206 required = true) @HeaderParam("ns") String ns) throws Exception{
208 ResponseBuilder response = MusicUtil.buildVersionResponse(VERSION, minorVersion, patchVersion);
209 Map<String, Object> resultMap = MusicCore.validateLock(lockId);
210 if (resultMap.containsKey("Error")) {
211 logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.INCORRECTDATA ,ErrorSeverity.CRITICAL, ErrorTypes.GENERALSERVICEERROR);
212 response.status(Status.BAD_REQUEST);
213 return response.entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(resultMap.get("Error"))).toMap()).build();
215 Map<String,String> userCredentials = MusicUtil.extractBasicAuthentication(authorization);
216 String userId = userCredentials.get(MusicUtil.USERID);
217 String password = userCredentials.get(MusicUtil.PASSWORD);
218 String keyspaceName = (String) resultMap.get("keyspace");
219 EELFLoggerDelegate.mdcPut("keyspace", "( "+keyspaceName+" ) ");
220 resultMap.remove("keyspace");
221 resultMap = MusicAuthentication.autheticateUser(ns, userId, password, keyspaceName, aid,
222 "accquireLockWithLease");
224 if (resultMap.containsKey("aid"))
225 resultMap.remove("aid");
226 if (!resultMap.isEmpty()) {
227 logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.MISSINGDATA ,ErrorSeverity.CRITICAL, ErrorTypes.AUTHENTICATIONERROR);
228 response.status(Status.UNAUTHORIZED);
229 return response.entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(resultMap.get("Error"))).toMap()).build();
231 String lockName = lockId.substring(lockId.indexOf('$')+1, lockId.lastIndexOf('$'));
232 ReturnType lockLeaseStatus = MusicCore.acquireLockWithLease(lockName, lockId, lockObj.getLeasePeriod());
233 if ( lockLeaseStatus.getResult().equals(ResultType.SUCCESS)) {
234 response.status(Status.OK);
236 response.status(Status.BAD_REQUEST);
238 return response.entity(new JsonResponse(lockLeaseStatus.getResult()).setLock(lockName)
239 .setMessage(lockLeaseStatus.getMessage())
240 .setLockLease(String.valueOf(lockObj.getLeasePeriod())).toMap()).build();
242 EELFLoggerDelegate.mdcRemove("keyspace");
248 @Path("/enquire/{lockname}")
249 @ApiOperation(value = "Get Lock Holder",
250 notes = "Gets the current Lock Holder",
251 response = Map.class)
252 @Produces(MediaType.APPLICATION_JSON)
253 public Response currentLockHolder(
254 @ApiParam(value="Lock Name",required=true) @PathParam("lockname") String lockName,
255 @ApiParam(value = "Minor Version",required = false) @HeaderParam(XMINORVERSION) String minorVersion,
256 @ApiParam(value = "Patch Version",required = false) @HeaderParam(XPATCHVERSION) String patchVersion,
257 @ApiParam(value = "Authorization", required = true) @HeaderParam(MusicUtil.AUTHORIZATION) String authorization,
258 @ApiParam(value = "AID", required = true) @HeaderParam("aid") String aid,
259 @ApiParam(value = "Application namespace",
260 required = true) @HeaderParam("ns") String ns) throws Exception{
262 ResponseBuilder response = MusicUtil.buildVersionResponse(VERSION, minorVersion, patchVersion);
263 Map<String, Object> resultMap = MusicCore.validateLock(lockName);
264 if (resultMap.containsKey("Error")) {
265 logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.INCORRECTDATA ,ErrorSeverity.CRITICAL, ErrorTypes.GENERALSERVICEERROR);
266 response.status(Status.BAD_REQUEST);
267 return response.entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(resultMap.get("Error"))).toMap()).build();
269 Map<String,String> userCredentials = MusicUtil.extractBasicAuthentication(authorization);
270 String userId = userCredentials.get(MusicUtil.USERID);
271 String password = userCredentials.get(MusicUtil.PASSWORD);
272 String keyspaceName = (String) resultMap.get("keyspace");
273 EELFLoggerDelegate.mdcPut("keyspace", "( "+keyspaceName+" ) ");
274 resultMap.remove("keyspace");
275 resultMap = MusicAuthentication.autheticateUser(ns, userId, password, keyspaceName, aid,
276 "currentLockHolder");
277 if (resultMap.containsKey("aid"))
278 resultMap.remove("aid");
279 if (!resultMap.isEmpty()) {
280 logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.MISSINGDATA ,ErrorSeverity.CRITICAL, ErrorTypes.AUTHENTICATIONERROR);
281 response.status(Status.UNAUTHORIZED);
282 return response.entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(resultMap.get("Error"))).toMap()).build();
284 String who = MusicCore.whoseTurnIsIt(lockName);
285 ResultType status = ResultType.SUCCESS;
288 status = ResultType.FAILURE;
289 error = "There was a problem getting the lock holder";
290 logger.error(EELFLoggerDelegate.errorLogger,"There was a problem getting the lock holder", AppMessages.INCORRECTDATA ,ErrorSeverity.CRITICAL, ErrorTypes.GENERALSERVICEERROR);
291 return response.status(Status.BAD_REQUEST).entity(new JsonResponse(status).setError(error).setLock(lockName).setLockHolder(who).toMap()).build();
293 return response.status(Status.OK).entity(new JsonResponse(status).setError(error).setLock(lockName).setLockHolder(who).toMap()).build();
295 EELFLoggerDelegate.mdcRemove("keyspace");
301 @ApiOperation(value = "Lock State",
302 notes = "Returns current Lock State and Holder.",
303 response = Map.class)
304 @Produces(MediaType.APPLICATION_JSON)
305 public Response currentLockState(
306 @ApiParam(value="Lock Name",required=true) @PathParam("lockname") String lockName,
307 @ApiParam(value = "Minor Version",required = false) @HeaderParam(XMINORVERSION) String minorVersion,
308 @ApiParam(value = "Patch Version",required = false) @HeaderParam(XPATCHVERSION) String patchVersion,
309 @ApiParam(value = "Authorization", required = true) @HeaderParam(MusicUtil.AUTHORIZATION) String authorization,
310 @ApiParam(value = "AID", required = true) @HeaderParam("aid") String aid,
311 @ApiParam(value = "Application namespace",
312 required = true) @HeaderParam("ns") String ns) throws Exception{
314 ResponseBuilder response = MusicUtil.buildVersionResponse(VERSION, minorVersion, patchVersion);
315 Map<String, Object> resultMap = MusicCore.validateLock(lockName);
316 if (resultMap.containsKey("Error")) {
317 logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.INCORRECTDATA ,ErrorSeverity.CRITICAL, ErrorTypes.GENERALSERVICEERROR);
318 response.status(Status.BAD_REQUEST);
319 return response.entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(resultMap.get("Error"))).toMap()).build();
321 String keyspaceName = (String) resultMap.get("keyspace");
322 EELFLoggerDelegate.mdcPut("keyspace", "( "+keyspaceName+" ) ");
323 resultMap.remove("keyspace");
324 Map<String,String> userCredentials = MusicUtil.extractBasicAuthentication(authorization);
325 String userId = userCredentials.get(MusicUtil.USERID);
326 String password = userCredentials.get(MusicUtil.PASSWORD);
327 resultMap.remove("keyspace");
328 resultMap = MusicAuthentication.autheticateUser(ns, userId, password, keyspaceName, aid,
329 "currentLockHolder");
330 if (resultMap.containsKey("aid"))
331 resultMap.remove("aid");
332 if (!resultMap.isEmpty()) {
333 logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.MISSINGDATA ,ErrorSeverity.CRITICAL, ErrorTypes.AUTHENTICATIONERROR);
334 response.status(Status.UNAUTHORIZED);
335 return response.entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(resultMap.get("Error"))).toMap()).build();
338 String who = MusicCore.whoseTurnIsIt(lockName);
339 ResultType status = ResultType.SUCCESS;
342 status = ResultType.FAILURE;
343 error = "There was a problem getting the lock holder";
344 logger.error(EELFLoggerDelegate.errorLogger,"There was a problem getting the lock holder", AppMessages.INCORRECTDATA ,ErrorSeverity.CRITICAL, ErrorTypes.GENERALSERVICEERROR);
345 return response.status(Status.BAD_REQUEST).entity(new JsonResponse(status).setError(error).setLock(lockName).setLockHolder(who).toMap()).build();
347 return response.status(Status.OK).entity(new JsonResponse(status).setError(error).setLock(lockName).setLockHolder(who).toMap()).build();
349 EELFLoggerDelegate.mdcRemove("keyspace");
352 //MusicLockState mls = MusicZKCore.getMusicLockState(lockName);
353 // Map<String,Object> returnMap = null;
354 // JsonResponse jsonResponse = new JsonResponse(ResultType.FAILURE).setLock(lockName);
356 // jsonResponse.setError("");
357 // jsonResponse.setMessage("No lock object created yet..");
358 // logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.INCORRECTDATA ,ErrorSeverity.CRITICAL, ErrorTypes.GENERALSERVICEERROR);
359 // return response.status(Status.BAD_REQUEST).entity(jsonResponse.toMap()).build();
361 // jsonResponse.setStatus(ResultType.SUCCESS);
362 // jsonResponse.setLockStatus(mls.getLockStatus());
363 // jsonResponse.setLockHolder(mls.getLockHolder());
364 // return response.status(Status.OK).entity(jsonResponse.toMap()).build();
371 * deletes the process from the zk queue
377 @Path("/release/{lockreference}")
378 @ApiOperation(value = "Release Lock",
379 notes = "deletes the process from the zk queue",
380 response = Map.class)
381 @Produces(MediaType.APPLICATION_JSON)
382 public Response unLock(@PathParam("lockreference") String lockId,
383 @ApiParam(value = "Minor Version",required = false) @HeaderParam(XMINORVERSION) String minorVersion,
384 @ApiParam(value = "Patch Version",required = false) @HeaderParam(XPATCHVERSION) String patchVersion,
385 @ApiParam(value = "Authorization", required = true) @HeaderParam(MusicUtil.AUTHORIZATION) String authorization,
386 @ApiParam(value = "AID", required = true) @HeaderParam("aid") String aid,
387 @ApiParam(value = "Application namespace",
388 required = true) @HeaderParam("ns") String ns) throws Exception{
390 ResponseBuilder response = MusicUtil.buildVersionResponse(VERSION, minorVersion, patchVersion);
391 Map<String, Object> resultMap = MusicCore.validateLock(lockId);
392 if (resultMap.containsKey("Error")) {
393 logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.INCORRECTDATA ,ErrorSeverity.CRITICAL, ErrorTypes.GENERALSERVICEERROR);
394 response.status(Status.BAD_REQUEST);
395 return response.entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(resultMap.get("Error"))).toMap()).build();
397 Map<String,String> userCredentials = MusicUtil.extractBasicAuthentication(authorization);
398 String userId = userCredentials.get(MusicUtil.USERID);
399 String password = userCredentials.get(MusicUtil.PASSWORD);
400 String keyspaceName = (String) resultMap.get("keyspace");
401 EELFLoggerDelegate.mdcPut("keyspace", "( "+keyspaceName+" ) ");
402 resultMap.remove("keyspace");
403 resultMap = MusicAuthentication.autheticateUser(ns, userId, password, keyspaceName, aid,
405 if (resultMap.containsKey("aid"))
406 resultMap.remove("aid");
407 if (!resultMap.isEmpty()) {
408 logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.MISSINGDATA ,ErrorSeverity.CRITICAL, ErrorTypes.AUTHENTICATIONERROR);
409 response.status(Status.UNAUTHORIZED);
410 return response.entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(resultMap.get("Error"))).toMap()).build();
412 boolean voluntaryRelease = true;
413 MusicLockState mls = MusicCore.releaseLock(lockId,voluntaryRelease);
414 if(mls.getErrorMessage() != null) {
415 resultMap.put(ResultType.EXCEPTION.getResult(), mls.getErrorMessage());
416 logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.INCORRECTDATA ,ErrorSeverity.CRITICAL, ErrorTypes.GENERALSERVICEERROR);
417 return response.status(Status.BAD_REQUEST).entity(resultMap).build();
419 Map<String,Object> returnMap = null;
420 if (mls.getLockStatus() == MusicLockState.LockStatus.UNLOCKED) {
421 returnMap = new JsonResponse(ResultType.SUCCESS).setLock(lockId)
422 .setLockStatus(mls.getLockStatus()).toMap();
423 response.status(Status.OK);
425 if (mls.getLockStatus() == MusicLockState.LockStatus.LOCKED) {
426 logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.LOCKINGERROR ,ErrorSeverity.CRITICAL, ErrorTypes.GENERALSERVICEERROR);
427 returnMap = new JsonResponse(ResultType.FAILURE).setLock(lockId)
428 .setLockStatus(mls.getLockStatus()).toMap();
429 response.status(Status.BAD_REQUEST);
431 return response.entity(returnMap).build();
433 EELFLoggerDelegate.mdcRemove("keyspace");
443 @Path("/delete/{lockname}")
444 @ApiOperation(value = "Delete Lock", response = Map.class)
445 @Produces(MediaType.APPLICATION_JSON)
446 public Response deleteLock(@PathParam("lockname") String lockName,
447 @ApiParam(value = "Minor Version",required = false) @HeaderParam(XMINORVERSION) String minorVersion,
448 @ApiParam(value = "Patch Version",required = false) @HeaderParam(XPATCHVERSION) String patchVersion,
449 @ApiParam(value = "AID", required = true) @HeaderParam("aid") String aid,
450 @ApiParam(value = "Authorization", required = true) @HeaderParam(MusicUtil.AUTHORIZATION) String authorization,
451 @ApiParam(value = "Application namespace",
452 required = true) @HeaderParam("ns") String ns) throws Exception{
454 ResponseBuilder response = MusicUtil.buildVersionResponse(VERSION, minorVersion, patchVersion);
455 Map<String, Object> resultMap = MusicCore.validateLock(lockName);
456 if (resultMap.containsKey("Error")) {
457 logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.UNKNOWNERROR ,ErrorSeverity.CRITICAL, ErrorTypes.GENERALSERVICEERROR);
458 response.status(Status.BAD_REQUEST);
459 return response.entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(resultMap.get("Error"))).toMap()).build();
461 Map<String,String> userCredentials = MusicUtil.extractBasicAuthentication(authorization);
462 String userId = userCredentials.get(MusicUtil.USERID);
463 String password = userCredentials.get(MusicUtil.PASSWORD);
464 String keyspaceName = (String) resultMap.get("keyspace");
465 EELFLoggerDelegate.mdcPut("keyspace", "( "+keyspaceName+" ) ");
466 resultMap.remove("keyspace");
467 resultMap = MusicAuthentication.autheticateUser(ns, userId, password, keyspaceName, aid,
469 if (resultMap.containsKey("aid"))
470 resultMap.remove("aid");
471 if (!resultMap.isEmpty()) {
472 logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.MISSINGDATA ,ErrorSeverity.CRITICAL, ErrorTypes.AUTHENTICATIONERROR);
473 response.status(Status.UNAUTHORIZED);
474 return response.entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(resultMap.get("Error"))).toMap()).build();
477 MusicCore.deleteLock(lockName);
478 }catch (Exception e) {
479 return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(e.getMessage()).toMap()).build();
481 return response.status(Status.OK).entity(new JsonResponse(ResultType.SUCCESS).toMap()).build();
483 EELFLoggerDelegate.mdcRemove("keyspace");