root
/
nacos
mirror of https://github.com/alibaba/nacos.git
1
0
Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity

[ISSUE #12962]Feat develop 3.0 dlock (#12981) 

* add simple Distributed lock

# Conflicts:
#	pom.xml

* add lock unit test.

* add lock unit test.

* add lock unit test.

* update lock instance

* add javadoc

* add nacoslock snapshot.

* add property.

* update property.

* add lock auth.

* fix lock auth.

* add lockInfo DTO.

* improve log and memory lack.

* merge 'develop' into lock

* add lock query count and rt metrics

* fix compile and test

---------

Co-authored-by: 985492783 <985492783@qq.com>
This commit is contained in:
shalk(xiao kun) 2025-01-02 12:00:39 +08:00 committed by GitHub
parent f0ad076e83
commit cd7de01ffc
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
60 changed files with 3047 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
api/src/main/java/com/alibaba/nacos/api/NacosFactory.java
View File

@ -19,6 +19,8 @@ package com.alibaba.nacos.api;
import com.alibaba.nacos.api.config.ConfigFactory;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.exception.NacosException;
import com.alibaba.nacos.api.lock.LockService;
import com.alibaba.nacos.api.lock.NacosLockFactory;
import com.alibaba.nacos.api.naming.NamingFactory;
import com.alibaba.nacos.api.naming.NamingMaintainFactory;
import com.alibaba.nacos.api.naming.NamingMaintainService;
@ -98,4 +100,15 @@ public class NacosFactory {
public static NamingMaintainService createMaintainService(Properties properties) throws NacosException {
return NamingMaintainFactory.createMaintainService(properties);
}
/**
* Create lock service.
*
* @param properties init param
* @return lock service
* @throws NacosException Exception
*/
public static LockService createLockService(Properties properties) throws NacosException {
return NacosLockFactory.createLockService(properties);
}
}

9
api/src/main/java/com/alibaba/nacos/api/common/Constants.java
View File

@ -276,6 +276,15 @@ public class Constants {
public static final String CMDB_CONTEXT_TYPE = "CMDB";
}
/**
* The constants in lock directory.
*/
public static class Lock {
public static final String LOCK_MODULE = "lock";
}
/**
* The constants in remote directory.
*/

80
api/src/main/java/com/alibaba/nacos/api/lock/LockService.java Normal file
View File

@ -0,0 +1,80 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.api.lock;
import com.alibaba.nacos.api.exception.NacosException;
import com.alibaba.nacos.api.lock.model.LockInstance;
import java.util.Properties;
/**
* Nacos Lock Process.
*
* <p>lock => {@link LockService#lock(LockInstance)} -> {@link LockInstance#lock(LockService)} ->
* {@link LockService#remoteTryLock(LockInstance)} <br/> unLock => {@link LockService#unLock(LockInstance)} ->
* {@link LockInstance#unLock(LockService)} -> {@link LockService#remoteReleaseLock(LockInstance)}
*
* @author 985492783@qq.com
* @date 2023/8/24 19:49
*/
public interface LockService {
/**
* Real lock method expose to user to acquire the lock.<br/> It will call {@link LockInstance#lock(LockService)}
* <br/>
*
* @param instance instance
* @return Boolean
* @throws NacosException NacosException
*/
Boolean lock(LockInstance instance) throws NacosException;
/**
* Real lock method expose to user to release the lock.<br/> It will call {@link LockInstance#unLock(LockService)}
* <br/>
*
* @param instance instance
* @return Boolean
* @throws NacosException NacosException
*/
Boolean unLock(LockInstance instance) throws NacosException;
/**
* use grpc request to try lock.
*
* @param instance instance
* @return Boolean
* @throws NacosException NacosException
*/
Boolean remoteTryLock(LockInstance instance) throws NacosException;
/**
* use grpc request to release lock.
*
* @param instance instance
* @return Boolean
* @throws NacosException NacosException
*/
Boolean remoteReleaseLock(LockInstance instance) throws NacosException;
/**
* get properties.
*
* @return Properties
*/
Properties getProperties();
}

48
api/src/main/java/com/alibaba/nacos/api/lock/NacosLockFactory.java Normal file
View File

@ -0,0 +1,48 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.api.lock;
import com.alibaba.nacos.api.exception.NacosException;
import java.lang.reflect.Constructor;
import java.util.Properties;
/**
* lock Factory.
*
* @author 985492783@qq.com
* @date 2023/8/25 0:40
*/
public class NacosLockFactory {
/**
* Create a new lock service.
*
* @param properties lock service properties
* @return new lock service
* @throws NacosException nacos exception
*/
public static LockService createLockService(Properties properties) throws NacosException {
try {
Class<?> driverImplClass = Class.forName("com.alibaba.nacos.client.lock.NacosLockService");
Constructor constructor = driverImplClass.getConstructor(Properties.class);
return (LockService) constructor.newInstance(properties);
} catch (Throwable e) {
throw new NacosException(NacosException.CLIENT_INVALID_PARAM, e);
}
}
}

28
api/src/main/java/com/alibaba/nacos/api/lock/common/LockConstants.java Normal file
View File

@ -0,0 +1,28 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.api.lock.common;
/**
* lock constant.
*
* @author 985492783@qq.com
* @date 2023/8/23 15:53
*/
public class LockConstants {
public static final String NACOS_LOCK_TYPE = "NACOS_LOCK";
}

31
api/src/main/java/com/alibaba/nacos/api/lock/constant/PropertyConstants.java Normal file
View File

@ -0,0 +1,31 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.api.lock.constant;
/**
* lock properties constants.
* @author 985492783@qq.com
* @description PropertyConstants
* @date 2023/6/28 17:38
*/
public class PropertyConstants {
public static final String LOCK_REQUEST_TIMEOUT = "lockRequestTimeout";
public static final String LOCK_DEFAULT_WAIT_TIME = "nacos.lock.default_wait_time";
public static final Long LOCK_DEFAULT_WAIT_SECOND = 10_000L;
}

112
api/src/main/java/com/alibaba/nacos/api/lock/model/LockInstance.java Normal file
View File

@ -0,0 +1,112 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.api.lock.model;
import com.alibaba.nacos.api.exception.NacosException;
import com.alibaba.nacos.api.lock.LockService;
import java.io.Serializable;
import java.util.Map;
/**
* lock info entity.
*
* @author 985492783@qq.com
* @date 2023/6/28 2:46
*/
public class LockInstance implements Serializable {
private static final long serialVersionUID = -3460985546826875524L;
private String key;
private Long expiredTime;
private Map<String, ? extends Serializable> params;
private String lockType;
public LockInstance(String key, Long expiredTime, String lockType) {
this.key = key;
this.expiredTime = expiredTime;
this.lockType = lockType;
}
public LockInstance() {
}
public Long getExpiredTime() {
return expiredTime;
}
public void setExpiredTime(Long expiredTime) {
this.expiredTime = expiredTime;
}
public String getKey() {
return key;
}
public void setKey(String key) {
this.key = key;
}
public Map<String, ? extends Serializable> getParams() {
return params;
}
public void setParams(Map<String, ? extends Serializable> params) {
this.params = params;
}
/**
* Will call {@link LockService#remoteTryLock(LockInstance)} request grpc to get lock and do something.<br/> can be
* {@link Override} to do some client special logic.
*
* @param lockService {@link LockService}
* @return Boolean {@link Boolean}
* @throws NacosException NacosException
*/
public Boolean lock(LockService lockService) throws NacosException {
return lockService.remoteTryLock(this);
}
/**
* Will call {@link LockService#remoteReleaseLock(LockInstance)} request grpc to release lock and do something.<br/>
* can be {@link Override} to do some client special logic.
*
* @param lockService {@link LockService}
* @return Boolean {@link Boolean}
* @throws NacosException NacosException
*/
public Boolean unLock(LockService lockService) throws NacosException {
return lockService.remoteReleaseLock(this);
}
/**
* spi get lock type.
*
* @return type
*/
public String getLockType() {
return lockType;
}
public void setLockType(String lockType) {
this.lockType = lockType;
}
}

36
api/src/main/java/com/alibaba/nacos/api/lock/remote/AbstractLockRequest.java Normal file
View File

@ -0,0 +1,36 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.api.lock.remote;
import com.alibaba.nacos.api.remote.request.Request;
import static com.alibaba.nacos.api.common.Constants.Lock.LOCK_MODULE;
/**
* lock grpc request.
*
* @author 985492783@qq.com
* @description LockRequest
* @date 2023/6/29 12:00
*/
public abstract class AbstractLockRequest extends Request {
@Override
public String getModule() {
return LOCK_MODULE;
}
}

41
api/src/main/java/com/alibaba/nacos/api/lock/remote/LockOperationEnum.java Normal file
View File

@ -0,0 +1,41 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.api.lock.remote;
import java.io.Serializable;
/**
* lock operation.
* @author 985492783@qq.com
*/
public enum LockOperationEnum implements Serializable {
/**
* Acquire.
*/
ACQUIRE,
/**
* Release.
*/
RELEASE,
/**
* Expire.
*/
EXPIRE;
private static final long serialVersionUID = -241044344531890549L;
}

51
api/src/main/java/com/alibaba/nacos/api/lock/remote/request/LockOperationRequest.java Normal file
View File

@ -0,0 +1,51 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.api.lock.remote.request;
import com.alibaba.nacos.api.lock.model.LockInstance;
import com.alibaba.nacos.api.lock.remote.AbstractLockRequest;
import com.alibaba.nacos.api.lock.remote.LockOperationEnum;
/**
* grpc acquire lock request.
*
* @author 985492783@qq.com
* @description AcquireLockRequest
* @date 2023/6/29 12:01
*/
public class LockOperationRequest extends AbstractLockRequest {
private LockInstance lockInstance;
private LockOperationEnum lockOperationEnum;
public LockInstance getLockInstance() {
return lockInstance;
}
public void setLockInstance(LockInstance lockInstance) {
this.lockInstance = lockInstance;
}
public LockOperationEnum getLockOperationEnum() {
return lockOperationEnum;
}
public void setLockOperationEnum(LockOperationEnum lockOperationEnum) {
this.lockOperationEnum = lockOperationEnum;
}
}

70
api/src/main/java/com/alibaba/nacos/api/lock/remote/response/LockOperationResponse.java Normal file
View File

@ -0,0 +1,70 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.api.lock.remote.response;
import com.alibaba.nacos.api.remote.response.Response;
import com.alibaba.nacos.api.remote.response.ResponseCode;
/**
* grpc acquire lock response.
*
* @author 985492783@qq.com
* @description AcquireLockResponse
* @date 2023/6/29 13:51
*/
public class LockOperationResponse extends Response {
private Object result;
public LockOperationResponse() {
}
public LockOperationResponse(Boolean result) {
this.result = result;
}
/**
* create success response.
* @param result result
* @return LockOperationResponse
*/
public static LockOperationResponse success(Boolean result) {
LockOperationResponse response = new LockOperationResponse(result);
return response;
}
/**
* create fail response.
* @param message message
* @return LockOperationResponse
*/
public static LockOperationResponse fail(String message) {
LockOperationResponse response = new LockOperationResponse(false);
response.setResultCode(ResponseCode.FAIL.getCode());
response.setMessage(message);
return response;
}
public Object getResult() {
return result;
}
public void setResult(Object result) {
this.result = result;
}
}

2
api/src/main/java/com/alibaba/nacos/api/remote/RemoteConstants.java
View File

@ -40,4 +40,6 @@ public class RemoteConstants {
public static final String LABEL_MODULE_NAMING = "naming";
public static final String MONITOR_LABEL_NONE = "none";
public static final String LABEL_MODULE_LOCK = "lock";
}

2
api/src/main/resources/META-INF/services/com.alibaba.nacos.api.remote.Payload
View File

@ -58,3 +58,5 @@ com.alibaba.nacos.api.naming.remote.response.NotifySubscriberResponse
com.alibaba.nacos.api.naming.remote.response.QueryServiceResponse
com.alibaba.nacos.api.naming.remote.response.ServiceListResponse
com.alibaba.nacos.api.naming.remote.response.SubscribeServiceResponse
com.alibaba.nacos.api.lock.remote.request.LockOperationRequest
com.alibaba.nacos.api.lock.remote.response.LockOperationResponse

2
client/src/main/java/com/alibaba/nacos/client/auth/ram/RamClientAuthServiceImpl.java
View File

@ -21,6 +21,7 @@ import com.alibaba.nacos.api.exception.NacosException;
import com.alibaba.nacos.client.auth.ram.identify.StsConfig;
import com.alibaba.nacos.client.auth.ram.injector.AbstractResourceInjector;
import com.alibaba.nacos.client.auth.ram.injector.ConfigResourceInjector;
import com.alibaba.nacos.client.auth.ram.injector.LockResourceInjector;
import com.alibaba.nacos.client.auth.ram.injector.NamingResourceInjector;
import com.alibaba.nacos.client.auth.ram.utils.RamUtil;
import com.alibaba.nacos.client.auth.ram.utils.SpasAdapter;
@ -54,6 +55,7 @@ public class RamClientAuthServiceImpl extends AbstractClientAuthService {
resourceInjectors = new HashMap<>();
resourceInjectors.put(SignType.NAMING, new NamingResourceInjector());
resourceInjectors.put(SignType.CONFIG, new ConfigResourceInjector());
resourceInjectors.put(SignType.LOCK, new LockResourceInjector());
}
@Override

54
client/src/main/java/com/alibaba/nacos/client/auth/ram/injector/LockResourceInjector.java Normal file
View File

@ -0,0 +1,54 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.client.auth.ram.injector;
import com.alibaba.nacos.client.auth.ram.RamContext;
import com.alibaba.nacos.client.auth.ram.identify.IdentifyConstants;
import com.alibaba.nacos.client.auth.ram.identify.StsConfig;
import com.alibaba.nacos.client.auth.ram.identify.StsCredential;
import com.alibaba.nacos.client.auth.ram.identify.StsCredentialHolder;
import com.alibaba.nacos.common.utils.StringUtils;
import com.alibaba.nacos.plugin.auth.api.LoginIdentityContext;
import com.alibaba.nacos.plugin.auth.api.RequestResource;
/**
* lock resource injector.
*
* @author 985492783@qq.com
* @date 2023/9/17 1:10
*/
public class LockResourceInjector extends AbstractResourceInjector {
private static final String AK_FIELD = "ak";
@Override
public void doInject(RequestResource resource, RamContext context, LoginIdentityContext result) {
String accessKey = context.getAccessKey();
String secretKey = context.getSecretKey();
// STS 临时凭证鉴权的优先级高于 AK/SK 鉴权
if (StsConfig.getInstance().isStsOn()) {
StsCredential stsCredential = StsCredentialHolder.getInstance().getStsCredential();
accessKey = stsCredential.getAccessKeyId();
secretKey = stsCredential.getAccessKeySecret();
result.setParameter(IdentifyConstants.SECURITY_TOKEN_HEADER, stsCredential.getSecurityToken());
}
if (StringUtils.isNotEmpty(accessKey) && StringUtils.isNotBlank(secretKey)) {
result.setParameter(AK_FIELD, accessKey);
}
}
}

99
client/src/main/java/com/alibaba/nacos/client/lock/NacosLockService.java Normal file
View File

@ -0,0 +1,99 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.client.lock;
import com.alibaba.nacos.api.exception.NacosException;
import com.alibaba.nacos.api.lock.LockService;
import com.alibaba.nacos.api.lock.model.LockInstance;
import com.alibaba.nacos.client.address.AbstractServerListManager;
import com.alibaba.nacos.client.env.NacosClientProperties;
import com.alibaba.nacos.client.lock.remote.grpc.LockGrpcClient;
import com.alibaba.nacos.client.naming.core.NamingServerListManager;
import com.alibaba.nacos.client.naming.remote.http.NamingHttpClientManager;
import com.alibaba.nacos.client.security.SecurityProxy;
import java.util.Properties;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import static com.alibaba.nacos.client.constant.Constants.Security.SECURITY_INFO_REFRESH_INTERVAL_MILLS;
/**
* nacos lock Service.
*
* @author 985492783@qq.com
* @date 2023/8/24 19:51
*/
@SuppressWarnings("PMD.ServiceOrDaoClassShouldEndWithImplRule")
public class NacosLockService implements LockService {
private final Properties properties;
private final LockGrpcClient lockGrpcClient;
private final SecurityProxy securityProxy;
private ScheduledExecutorService executorService;
public NacosLockService(Properties properties) throws NacosException {
this.properties = properties;
NacosClientProperties nacosClientProperties = NacosClientProperties.PROTOTYPE.derive(properties);
AbstractServerListManager serverListManager = new NamingServerListManager(properties);
this.securityProxy = new SecurityProxy(serverListManager,
NamingHttpClientManager.getInstance().getNacosRestTemplate());
initSecurityProxy(nacosClientProperties);
this.lockGrpcClient = new LockGrpcClient(nacosClientProperties, serverListManager, securityProxy);
}
private void initSecurityProxy(NacosClientProperties properties) {
this.executorService = new ScheduledThreadPoolExecutor(1, r -> {
Thread t = new Thread(r);
t.setName("com.alibaba.nacos.client.lock.security");
t.setDaemon(true);
return t;
});
final Properties nacosClientPropertiesView = properties.asProperties();
this.securityProxy.login(nacosClientPropertiesView);
this.executorService.scheduleWithFixedDelay(() -> securityProxy.login(nacosClientPropertiesView), 0,
SECURITY_INFO_REFRESH_INTERVAL_MILLS, TimeUnit.MILLISECONDS);
}
@Override
public Boolean lock(LockInstance instance) throws NacosException {
return instance.lock(this);
}
@Override
public Boolean unLock(LockInstance instance) throws NacosException {
return instance.unLock(this);
}
@Override
public Boolean remoteTryLock(LockInstance instance) throws NacosException {
return lockGrpcClient.lock(instance);
}
@Override
public Boolean remoteReleaseLock(LockInstance instance) throws NacosException {
return lockGrpcClient.unLock(instance);
}
public Properties getProperties() {
return properties;
}
}

39
client/src/main/java/com/alibaba/nacos/client/lock/core/NLock.java Normal file
View File

@ -0,0 +1,39 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.client.lock.core;
import com.alibaba.nacos.api.lock.common.LockConstants;
import com.alibaba.nacos.api.lock.model.LockInstance;
/**
* Nacos client lock entity.
*
* @author 985492783@qq.com
* @date 2023/8/24 19:52
*/
@SuppressWarnings("PMD.ClassNamingShouldBeCamelRule")
public class NLock extends LockInstance {
private static final long serialVersionUID = -346054842454875524L;
public NLock() {
}
public NLock(String key, Long expireTimestamp) {
super(key, expireTimestamp, LockConstants.NACOS_LOCK_TYPE);
}
}

47
client/src/main/java/com/alibaba/nacos/client/lock/core/NLockFactory.java Normal file
View File

@ -0,0 +1,47 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.client.lock.core;
/**
* NLock factory.
*
* @author 985492783@qq.com
* @date 2023/8/27 15:23
*/
@SuppressWarnings("PMD.ClassNamingShouldBeCamelRule")
public class NLockFactory {
/**
* create NLock without expireTime.
*
* @param key key
* @return NLock
*/
public static NLock getLock(String key) {
return new NLock(key, -1L);
}
/**
* create NLock with expireTime.
*
* @param key key
* @return NLock
*/
public static NLock getLock(String key, Long expireTimestamp) {
return new NLock(key, expireTimestamp);
}
}

53
client/src/main/java/com/alibaba/nacos/client/lock/remote/AbstractLockClient.java Normal file
View File

@ -0,0 +1,53 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.client.lock.remote;
import com.alibaba.nacos.client.security.SecurityProxy;
import com.alibaba.nacos.client.utils.AppNameUtils;
import com.alibaba.nacos.plugin.auth.api.RequestResource;
import java.util.HashMap;
import java.util.Map;
/**
* abstract lock client.
* @author 985492783@qq.com
* @description AbstractLockClient
* @date 2023/6/28 17:19
*/
public abstract class AbstractLockClient implements LockClient {
private final SecurityProxy securityProxy;
private static final String APP_FILED = "app";
protected AbstractLockClient(SecurityProxy securityProxy) {
this.securityProxy = securityProxy;
}
protected Map<String, String> getSecurityHeaders() {
RequestResource resource = RequestResource.lockBuilder().build();
Map<String, String> result = this.securityProxy.getIdentityContext(resource);
result.putAll(getAppHeaders());
return result;
}
protected Map<String, String> getAppHeaders() {
Map<String, String> result = new HashMap<>(1);
result.put(APP_FILED, AppNameUtils.getAppName());
return result;
}
}

50
client/src/main/java/com/alibaba/nacos/client/lock/remote/LockClient.java Normal file
View File

@ -0,0 +1,50 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.client.lock.remote;
import com.alibaba.nacos.api.exception.NacosException;
import com.alibaba.nacos.api.lock.model.LockInstance;
import com.alibaba.nacos.common.lifecycle.Closeable;
/**
* lock client interface.
*
* @author 985492783@qq.com
* @description LockClient
* @date 2023/6/28 17:19
*/
public interface LockClient extends Closeable {
/**
* lock client get lock.
*
* @param instance instance.
* @return Boolean.
* @throws NacosException nacos Exception.
*/
Boolean lock(LockInstance instance) throws NacosException;
/**
* lock client unLock.
*
* @param instance instance.
* @return Boolean.
* @throws NacosException nacos Exception.
*/
Boolean unLock(LockInstance instance) throws NacosException;
}

120
client/src/main/java/com/alibaba/nacos/client/lock/remote/grpc/LockGrpcClient.java Normal file
View File

@ -0,0 +1,120 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.client.lock.remote.grpc;
import com.alibaba.nacos.api.common.Constants;
import com.alibaba.nacos.api.exception.NacosException;
import com.alibaba.nacos.api.lock.constant.PropertyConstants;
import com.alibaba.nacos.api.lock.model.LockInstance;
import com.alibaba.nacos.api.lock.remote.AbstractLockRequest;
import com.alibaba.nacos.api.lock.remote.LockOperationEnum;
import com.alibaba.nacos.api.lock.remote.request.LockOperationRequest;
import com.alibaba.nacos.api.lock.remote.response.LockOperationResponse;
import com.alibaba.nacos.api.remote.RemoteConstants;
import com.alibaba.nacos.api.remote.response.Response;
import com.alibaba.nacos.api.remote.response.ResponseCode;
import com.alibaba.nacos.client.env.NacosClientProperties;
import com.alibaba.nacos.client.lock.remote.AbstractLockClient;
import com.alibaba.nacos.client.security.SecurityProxy;
import com.alibaba.nacos.client.utils.AppNameUtils;
import com.alibaba.nacos.common.remote.ConnectionType;
import com.alibaba.nacos.common.remote.client.RpcClient;
import com.alibaba.nacos.common.remote.client.RpcClientFactory;
import com.alibaba.nacos.common.remote.client.RpcClientTlsConfigFactory;
import com.alibaba.nacos.common.remote.client.ServerListFactory;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
/**
* lock grpc client.
*
* @author 985492783@qq.com
* @description LockGrpcClient
* @date 2023/6/28 17:35
*/
public class LockGrpcClient extends AbstractLockClient {
private final String uuid;
private final Long requestTimeout;
private final RpcClient rpcClient;
public LockGrpcClient(NacosClientProperties properties, ServerListFactory serverListFactory,
SecurityProxy securityProxy) throws NacosException {
super(securityProxy);
this.uuid = UUID.randomUUID().toString();
this.requestTimeout = Long.parseLong(properties.getProperty(PropertyConstants.LOCK_REQUEST_TIMEOUT, "-1"));
Map<String, String> labels = new HashMap<>();
labels.put(RemoteConstants.LABEL_SOURCE, RemoteConstants.LABEL_SOURCE_SDK);
labels.put(RemoteConstants.LABEL_MODULE, RemoteConstants.LABEL_MODULE_LOCK);
labels.put(Constants.APPNAME, AppNameUtils.getAppName());
this.rpcClient = RpcClientFactory.createClient(uuid, ConnectionType.GRPC, labels,
RpcClientTlsConfigFactory.getInstance().createSdkConfig(properties.asProperties()));
start(serverListFactory);
}
private void start(ServerListFactory serverListFactory) throws NacosException {
rpcClient.serverListFactory(serverListFactory);
rpcClient.start();
}
@Override
public Boolean lock(LockInstance instance) throws NacosException {
LockOperationRequest request = new LockOperationRequest();
request.setLockInstance(instance);
request.setLockOperationEnum(LockOperationEnum.ACQUIRE);
LockOperationResponse acquireLockResponse = requestToServer(request, LockOperationResponse.class);
return (Boolean) acquireLockResponse.getResult();
}
@Override
public Boolean unLock(LockInstance instance) throws NacosException {
LockOperationRequest request = new LockOperationRequest();
request.setLockInstance(instance);
request.setLockOperationEnum(LockOperationEnum.RELEASE);
LockOperationResponse acquireLockResponse = requestToServer(request, LockOperationResponse.class);
return (Boolean) acquireLockResponse.getResult();
}
@Override
public void shutdown() throws NacosException {
}
private <T extends Response> T requestToServer(AbstractLockRequest request, Class<T> responseClass)
throws NacosException {
try {
request.putAllHeader(getSecurityHeaders());
Response response =
requestTimeout < 0 ? rpcClient.request(request) : rpcClient.request(request, requestTimeout);
if (ResponseCode.SUCCESS.getCode() != response.getResultCode()) {
throw new NacosException(response.getErrorCode(), response.getMessage());
}
if (responseClass.isAssignableFrom(response.getClass())) {
return (T) response;
}
} catch (NacosException e) {
throw e;
} catch (Exception e) {
throw new NacosException(NacosException.SERVER_ERROR, "Request nacos server failed: ", e);
}
throw new NacosException(NacosException.SERVER_ERROR, "Server return invalid response");
}
}

3
config/src/test/java/com/alibaba/nacos/config/server/remote/ConfigQueryRequestHandlerTest.java
View File

@ -36,6 +36,7 @@ import com.alibaba.nacos.config.server.utils.PropertyUtil;
import com.alibaba.nacos.sys.env.EnvUtil;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.MockedStatic;
@ -54,7 +55,9 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.when;
// todo open the test case
@ExtendWith(MockitoExtension.class)
@Disabled
class ConfigQueryRequestHandlerTest {
static MockedStatic<ConfigCacheService> configCacheServiceMockedStatic;

4
console/pom.xml
View File

@ -38,6 +38,10 @@
<groupId>${project.groupId}</groupId>
<artifactId>nacos-naming</artifactId>
</dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>nacos-lock</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba.nacos</groupId>

5
console/src/main/resources/application.properties
View File

@ -246,3 +246,8 @@ nacos.k8s.sync.enabled=false
### If use the Java API from an application outside a kubernetes cluster
#nacos.k8s.sync.outsideCluster=false
#nacos.k8s.sync.kubeConfig=/.kube/config
#*************** DistributedLock Configurations ***************#
# nacos.lock.default_expire_time = 30000000
# nacos.lock.max_expire_time = 1800000000

7
console/src/test/java/com/alibaba/nacos/console/controller/v3/naming/ConsoleServiceControllerTest.java
View File

@ -38,7 +38,6 @@ import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.omg.CORBA.ServiceDetail;
import java.util.Collections;
import java.util.List;
@ -136,7 +135,7 @@ public class ConsoleServiceControllerTest {
@Test
void testGetServiceDetail() throws Exception {
ServiceDetail serviceDetail = new ServiceDetail();
Object serviceDetail = new Object();
when(serviceProxy.getServiceDetail(any(String.class), any(String.class), any(String.class))).thenReturn(
serviceDetail);
@ -144,7 +143,7 @@ public class ConsoleServiceControllerTest {
serviceForm.setServiceName("testService");
serviceForm.setNamespaceId("testNamespace");
serviceForm.setGroupName("testGroup");
Result<ServiceDetail> actual = (Result<ServiceDetail>) consoleServiceController.getServiceDetail(serviceForm);
Result<Object> actual = (Result<Object>) consoleServiceController.getServiceDetail(serviceForm);
verify(serviceProxy).getServiceDetail(any(String.class), any(String.class), any(String.class));
@ -193,7 +192,7 @@ public class ConsoleServiceControllerTest {
@Test
void testGetServiceList() throws Exception {
when(serviceProxy.getServiceList(anyBoolean(), anyString(), anyInt(), anyInt(), anyString(), anyString(),
anyBoolean())).thenReturn(Collections.singletonList(new ServiceDetail()));
anyBoolean())).thenReturn(Collections.singletonList(new Object()));
PageForm pageForm = new PageForm();
pageForm.setPageNo(1);
pageForm.setPageSize(10);

4
core/src/main/java/com/alibaba/nacos/core/monitor/NacosMeterRegistryCenter.java
View File

@ -50,6 +50,8 @@ public final class NacosMeterRegistryCenter {
// control plugin registeres.
public static final String CONTROL_DENIED_REGISTRY = "CONTROL_DENIED_REGISTRY";
public static final String LOCK_STABLE_REGISTRY = "LOCK_STABLE_REGISTRY";
private static final ConcurrentHashMap<String, CompositeMeterRegistry> METER_REGISTRIES = new ConcurrentHashMap<>();
private static CompositeMeterRegistry METER_REGISTRY = null;
@ -61,7 +63,7 @@ public final class NacosMeterRegistryCenter {
Loggers.CORE.warn("Metrics init failed :", t);
}
registry(CORE_STABLE_REGISTRY, CONFIG_STABLE_REGISTRY, NAMING_STABLE_REGISTRY, TOPN_CONFIG_CHANGE_REGISTRY,
TOPN_SERVICE_CHANGE_REGISTRY, CONTROL_DENIED_REGISTRY);
TOPN_SERVICE_CHANGE_REGISTRY, CONTROL_DENIED_REGISTRY, LOCK_STABLE_REGISTRY);
}

58
lock/pom.xml Normal file
View File

@ -0,0 +1,58 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--
~ Copyright 1999-2023 Alibaba Group Holding Ltd.
~
~ Licensed under the Apache License, Version 2.0 (the "License");
~ you may not use this file except in compliance with the License.
~ You may obtain a copy of the License at
~
~ http://www.apache.org/licenses/LICENSE-2.0
~
~ Unless required by applicable law or agreed to in writing, software
~ distributed under the License is distributed on an "AS IS" BASIS,
~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
~ See the License for the specific language governing permissions and
~ limitations under the License.
-->
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<groupId>com.alibaba.nacos</groupId>
<artifactId>nacos-all</artifactId>
<version>${revision}</version>
<relativePath>../pom.xml</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>nacos-lock</artifactId>
<name>nacos-lock ${project.version}</name>
<url>https://nacos.io</url>
<dependencies>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>nacos-core</artifactId>
</dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>nacos-api</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
</project>

55
lock/src/main/java/com/alibaba/nacos/lock/LockManager.java Normal file
View File

@ -0,0 +1,55 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock;
import com.alibaba.nacos.lock.core.reentrant.AtomicLockService;
import com.alibaba.nacos.lock.model.LockKey;
import java.util.concurrent.ConcurrentHashMap;
/**
* lock manager.
*
* @author 985492783@qq.com
* @description LockManager
* @date 2023/7/10 15:10
*/
public interface LockManager {
/**
* get mutex lock.
*
* @param lockKey lock key
* @return AbstractAtomicLock
*/
AtomicLockService getMutexLock(LockKey lockKey);
/**
* show all atomicLock entity to snapshot save.
*
* @return Map
*/
ConcurrentHashMap<LockKey, AtomicLockService> showLocks();
/**
* remove mutex lock.
*
* @param lockKey lock key
* @return AbstractAtomicLock
*/
AtomicLockService removeMutexLock(LockKey lockKey);
}

80
lock/src/main/java/com/alibaba/nacos/lock/NacosLockManager.java Normal file
View File

@ -0,0 +1,80 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock;
import com.alibaba.nacos.common.spi.NacosServiceLoader;
import com.alibaba.nacos.lock.core.reentrant.AtomicLockService;
import com.alibaba.nacos.lock.exception.NacosLockException;
import com.alibaba.nacos.lock.factory.LockFactory;
import com.alibaba.nacos.lock.model.LockKey;
import org.springframework.stereotype.Service;
import java.util.Collection;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
/**
* nacos lock manager.
*
* @author 985492783@qq.com
* @date 2023/8/22 21:01
*/
@Service
public class NacosLockManager implements LockManager {
private final Map<String, LockFactory> factoryMap;
private final ConcurrentHashMap<LockKey, AtomicLockService> atomicLockMap = new ConcurrentHashMap<>();
public NacosLockManager() {
Collection<LockFactory> factories = NacosServiceLoader.load(LockFactory.class);
factoryMap = factories.stream()
.collect(Collectors.toConcurrentMap(LockFactory::getLockType, lockFactory -> lockFactory));
}
@Override
public AtomicLockService getMutexLock(LockKey lockKey) {
if (lockKey == null || lockKey.getLockType() == null || lockKey.getKey() == null) {
throw new NacosLockException("lockType or lockKey is null.");
}
if (!factoryMap.containsKey(lockKey.getLockType())) {
throw new NacosLockException("lockType: " + lockKey.getLockType() + " is not exist.");
}
return atomicLockMap.computeIfAbsent(lockKey, lock -> {
LockFactory lockFactory = factoryMap.get(lock.getLockType());
return lockFactory.createLock(lock.getKey());
});
}
@Override
public ConcurrentHashMap<LockKey, AtomicLockService> showLocks() {
return atomicLockMap;
}
@Override
public AtomicLockService removeMutexLock(LockKey lockKey) {
if (lockKey == null || lockKey.getLockType() == null || lockKey.getKey() == null) {
throw new NacosLockException("lockType or lockKey is null.");
}
if (!factoryMap.containsKey(lockKey.getLockType())) {
throw new NacosLockException("lockType: " + lockKey.getLockType() + " is not exist.");
}
return atomicLockMap.remove(lockKey);
}
}

59
lock/src/main/java/com/alibaba/nacos/lock/aspect/RequestLockAspect.java Normal file
View File

@ -0,0 +1,59 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock.aspect;
import com.alibaba.nacos.api.lock.remote.request.LockOperationRequest;
import com.alibaba.nacos.api.lock.remote.response.LockOperationResponse;
import com.alibaba.nacos.api.remote.request.RequestMeta;
import com.alibaba.nacos.lock.monitor.LockMetricsMonitor;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;
/**
* RequestLockAspect.
* @author goumang.zh@alibaba-inc.com
*/
@Aspect
@Component
public class RequestLockAspect {
/**
* count metrics and get handler time.
*/
@SuppressWarnings("checkstyle:linelength")
@Around(value = "execution(* com.alibaba.nacos.core.remote.RequestHandler.handleRequest(..)) && target(com.alibaba.nacos.lock.remote.rpc.handler.LockRequestHandler) && args(request, meta)", argNames = "pjp,request,meta")
public Object lockMeterPoint(ProceedingJoinPoint pjp, LockOperationRequest request, RequestMeta meta)
throws Throwable {
long st = System.currentTimeMillis();
try {
LockMetricsMonitor.getTotalMeter(request.getLockOperationEnum()).incrementAndGet();
LockOperationResponse result = (LockOperationResponse) pjp.proceed();
if (result.isSuccess()) {
LockMetricsMonitor.getSuccessMeter(request.getLockOperationEnum()).incrementAndGet();
}
return result;
} finally {
long rt = System.currentTimeMillis() - st;
LockMetricsMonitor.getLockHandlerTimer().record(rt, TimeUnit.MILLISECONDS);
}
}
}

28
lock/src/main/java/com/alibaba/nacos/lock/constant/Constants.java Normal file
View File

@ -0,0 +1,28 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock.constant;
/**
* constants.
* @author 985492783@qq.com
* @description Constants
* @date 2023/7/10 15:54
*/
public class Constants {
public static final String LOCK_ACQUIRE_SERVICE_GROUP_V2 = "lock_acquire_service_v2";
}

34
lock/src/main/java/com/alibaba/nacos/lock/constant/PropertiesConstant.java Normal file
View File

@ -0,0 +1,34 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock.constant;
/**
* properties constant.
*
* @author 985492783@qq.com
* @date 2023/8/25 0:50
*/
public class PropertiesConstant {
public static final String DEFAULT_AUTO_EXPIRE = "nacos.lock.default_expire_time";
public static final String MAX_AUTO_EXPIRE = "nacos.lock.max_expire_time";
public static final Long DEFAULT_AUTO_EXPIRE_TIME = 30_000L;
public static final Long MAX_AUTO_EXPIRE_TIME = 1800_000L;
}

42
lock/src/main/java/com/alibaba/nacos/lock/core/reentrant/AbstractAtomicLock.java Normal file
View File

@ -0,0 +1,42 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock.core.reentrant;
import java.io.Serializable;
/**
* abstract atomic lock.
*
* @author 985492783@qq.com
* @description AtomicLock
* @date 2023/7/10 14:50
*/
public abstract class AbstractAtomicLock implements AtomicLockService, Serializable {
private static final long serialVersionUID = -3460985546856855524L;
private final String key;
public AbstractAtomicLock(String key) {
this.key = key;
}
@Override
public String getKey() {
return key;
}
}

63
lock/src/main/java/com/alibaba/nacos/lock/core/reentrant/AtomicLockService.java Normal file
View File

@ -0,0 +1,63 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock.core.reentrant;
import com.alibaba.nacos.lock.model.LockInfo;
/**
* Atomic Lock Service.
*
* @author 985492783@qq.com
* @description AtomicLockService
* @date 2023/7/10 15:34
*/
public interface AtomicLockService {
/**
* try lock with expireTime.
*
* @param lockInfo request Lock
* @return boolean
*/
Boolean tryLock(LockInfo lockInfo);
/**
* release lock.
*
* @param lockInfo instance
* @return boolean
*/
Boolean unLock(LockInfo lockInfo);
/**
* return is auto expire.
* @return Boolean
*/
Boolean autoExpire();
/**
* get key.
* @return key
*/
String getKey();
/**
* judge lock is clear to gc.
* @return boolean
*/
Boolean isClear();
}

71
lock/src/main/java/com/alibaba/nacos/lock/core/reentrant/mutex/MutexAtomicLock.java Normal file
View File

@ -0,0 +1,71 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock.core.reentrant.mutex;
import com.alibaba.nacos.lock.core.reentrant.AbstractAtomicLock;
import com.alibaba.nacos.lock.model.LockInfo;
import java.util.concurrent.atomic.AtomicInteger;
/**
* MutexAtomicLock.
*
* @author 985492783@qq.com
* @description MutexAtomicLock
* @date 2023/7/10 15:33
*/
public class MutexAtomicLock extends AbstractAtomicLock {
private static final Integer EMPTY = 0;
private static final Integer FULL = 1;
private final AtomicInteger state;
private Long expiredTimestamp;
public MutexAtomicLock(String key) {
super(key);
this.state = new AtomicInteger(EMPTY);
}
@Override
public Boolean tryLock(LockInfo lockInfo) {
Long endTime = lockInfo.getEndTime();
if (state.compareAndSet(EMPTY, FULL) || autoExpire()) {
this.expiredTimestamp = endTime;
return true;
}
return false;
}
@Override
public Boolean unLock(LockInfo lockInfo) {
return state.compareAndSet(FULL, EMPTY);
}
@Override
public Boolean autoExpire() {
return System.currentTimeMillis() >= this.expiredTimestamp;
}
@Override
public Boolean isClear() {
return EMPTY.equals(state.get()) || autoExpire();
}
}

45
lock/src/main/java/com/alibaba/nacos/lock/exception/NacosLockException.java Normal file
View File

@ -0,0 +1,45 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock.exception;
/**
* NacosLockException.
*
* @author 985492783@qq.com
* @date 2023/11/18 18:57
*/
public class NacosLockException extends RuntimeException {
public NacosLockException() {
}
public NacosLockException(String message) {
super(message);
}
public NacosLockException(String message, Throwable cause) {
super(message, cause);
}
public NacosLockException(Throwable cause) {
super(cause);
}
public NacosLockException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
}

41
lock/src/main/java/com/alibaba/nacos/lock/factory/LockFactory.java Normal file
View File

@ -0,0 +1,41 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock.factory;
import com.alibaba.nacos.lock.core.reentrant.AbstractAtomicLock;
/**
* lock factory.
*
* @author 985492783@qq.com
* @date 2023/8/22 20:57
*/
public interface LockFactory {
/**
* spi lock factory type.
* @return type
*/
String getLockType();
/**
* create spi lock entity.
* @param key key
* @return AbstractAtomicLock
*/
AbstractAtomicLock createLock(String key);
}

40
lock/src/main/java/com/alibaba/nacos/lock/factory/SimpleLockFactory.java Normal file
View File

@ -0,0 +1,40 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock.factory;
import com.alibaba.nacos.api.lock.common.LockConstants;
import com.alibaba.nacos.lock.core.reentrant.AbstractAtomicLock;
import com.alibaba.nacos.lock.core.reentrant.mutex.MutexAtomicLock;
/**
* lock factory.
*
* @author 985492783@qq.com
* @date 2023/8/22 21:16
*/
public class SimpleLockFactory implements LockFactory {
@Override
public String getLockType() {
return LockConstants.NACOS_LOCK_TYPE;
}
@Override
public AbstractAtomicLock createLock(String key) {
return new MutexAtomicLock(key);
}
}

64
lock/src/main/java/com/alibaba/nacos/lock/model/LockInfo.java Normal file
View File

@ -0,0 +1,64 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock.model;
import java.io.Serializable;
import java.util.Map;
/**
* lock info DTO.
*
* @author 985492783@qq.com
* @date 2023/9/17 14:20
*/
public class LockInfo implements Serializable {
private static final long serialVersionUID = -3460985546826875524L;
private LockKey key;
private Long endTime;
private Map<String, ? extends Serializable> params;
public LockInfo() {
}
public LockKey getKey() {
return key;
}
public void setKey(LockKey key) {
this.key = key;
}
public Long getEndTime() {
return endTime;
}
public void setEndTime(Long endTime) {
this.endTime = endTime;
}
public Map<String, ? extends Serializable> getParams() {
return params;
}
public void setParams(Map<String, ? extends Serializable> params) {
this.params = params;
}
}

73
lock/src/main/java/com/alibaba/nacos/lock/model/LockKey.java Normal file
View File

@ -0,0 +1,73 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock.model;
import java.io.Serializable;
import java.util.Objects;
/**
* lock key type and key name.
*
* @author 985492783@qq.com
* @date 2023/9/7 21:31
*/
public class LockKey implements Serializable {
private static final long serialVersionUID = -3460548121526875524L;
public LockKey(String lockType, String key) {
this.lockType = lockType;
this.key = key;
}
private String lockType;
private String key;
public String getLockType() {
return lockType;
}
public void setLockType(String lockType) {
this.lockType = lockType;
}
public String getKey() {
return key;
}
public void setKey(String key) {
this.key = key;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
LockKey lockKey = (LockKey) o;
return Objects.equals(lockType, lockKey.lockType) && Objects.equals(key, lockKey.key);
}
@Override
public int hashCode() {
return Objects.hash(lockType, key);
}
}

40
lock/src/main/java/com/alibaba/nacos/lock/monitor/LockMemoryMonitor.java Normal file
View File

@ -0,0 +1,40 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock.monitor;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
/**
* memory monitor.
*
* @author goumang.zh@alibaba-inc.com
*/
@Service
public class LockMemoryMonitor {
/**
* auto clean metrics per-day.
*/
@Scheduled(cron = "0 0 0 * * ?")
public void clear() {
LockMetricsMonitor.getGrpcLockTotal().set(0);
LockMetricsMonitor.getGrpcLockSuccess().set(0);
LockMetricsMonitor.getGrpcUnLockTotal().set(0);
LockMetricsMonitor.getGrpcUnLockSuccess().set(0);
}
}

111
lock/src/main/java/com/alibaba/nacos/lock/monitor/LockMetricsMonitor.java Normal file
View File

@ -0,0 +1,111 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock.monitor;
import com.alibaba.nacos.api.lock.remote.LockOperationEnum;
import com.alibaba.nacos.core.monitor.NacosMeterRegistryCenter;
import io.micrometer.core.instrument.ImmutableTag;
import io.micrometer.core.instrument.Tag;
import io.micrometer.core.instrument.Timer;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
/**
* MetricsMonitor.
* @author goumang.zh@alibaba-inc.com
*/
public class LockMetricsMonitor {
private static final String METER_REGISTRY = NacosMeterRegistryCenter.LOCK_STABLE_REGISTRY;
private static AtomicInteger grpcLockSuccess = new AtomicInteger();
private static AtomicInteger grpcUnLockSuccess = new AtomicInteger();
private static AtomicInteger grpcLockTotal = new AtomicInteger();
private static AtomicInteger grpcUnLockTotal = new AtomicInteger();
private static AtomicInteger aliveLockCount = new AtomicInteger();
static {
ImmutableTag immutableTag = new ImmutableTag("module", "lock");
List<Tag> tags = new ArrayList<>();
tags.add(immutableTag);
tags.add(new ImmutableTag("name", "grpcLockTotal"));
NacosMeterRegistryCenter.gauge(METER_REGISTRY, "nacos_monitor", tags, grpcLockTotal);
tags = new ArrayList<>();
tags.add(immutableTag);
tags.add(new ImmutableTag("name", "grpcLockSuccess"));
NacosMeterRegistryCenter.gauge(METER_REGISTRY, "nacos_monitor", tags, grpcLockSuccess);
tags = new ArrayList<>();
tags.add(immutableTag);
tags.add(new ImmutableTag("name", "grpcUnLockTotal"));
NacosMeterRegistryCenter.gauge(METER_REGISTRY, "nacos_monitor", tags, grpcUnLockTotal);
tags = new ArrayList<>();
tags.add(immutableTag);
tags.add(new ImmutableTag("name", "grpcUnLockSuccess"));
NacosMeterRegistryCenter.gauge(METER_REGISTRY, "nacos_monitor", tags, grpcUnLockSuccess);
tags = new ArrayList<>();
tags.add(immutableTag);
tags.add(new ImmutableTag("name", "aliveLockCount"));
NacosMeterRegistryCenter.gauge(METER_REGISTRY, "nacos_monitor", tags, aliveLockCount);
}
public static AtomicInteger getGrpcLockSuccess() {
return grpcLockSuccess;
}
public static AtomicInteger getGrpcUnLockSuccess() {
return grpcUnLockSuccess;
}
public static AtomicInteger getGrpcLockTotal() {
return grpcLockTotal;
}
public static AtomicInteger getGrpcUnLockTotal() {
return grpcUnLockTotal;
}
public static Timer getLockHandlerTimer() {
return NacosMeterRegistryCenter
.timer(METER_REGISTRY, "nacos_timer", "module", "lock", "name", "lockHandlerRt");
}
public static AtomicInteger getSuccessMeter(LockOperationEnum lockOperationEnum) {
if (lockOperationEnum == LockOperationEnum.ACQUIRE) {
return grpcLockSuccess;
} else {
return grpcUnLockSuccess;
}
}
public static AtomicInteger getTotalMeter(LockOperationEnum lockOperationEnum) {
if (lockOperationEnum == LockOperationEnum.ACQUIRE) {
return grpcLockTotal;
} else {
return grpcUnLockTotal;
}
}
}

159
lock/src/main/java/com/alibaba/nacos/lock/persistence/NacosLockSnapshotOperation.java Normal file
View File

@ -0,0 +1,159 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock.persistence;
import com.alibaba.nacos.consistency.SerializeFactory;
import com.alibaba.nacos.consistency.Serializer;
import com.alibaba.nacos.consistency.snapshot.LocalFileMeta;
import com.alibaba.nacos.consistency.snapshot.Reader;
import com.alibaba.nacos.consistency.snapshot.SnapshotOperation;
import com.alibaba.nacos.consistency.snapshot.Writer;
import com.alibaba.nacos.core.distributed.raft.utils.RaftExecutor;
import com.alibaba.nacos.core.utils.Loggers;
import com.alibaba.nacos.lock.LockManager;
import com.alibaba.nacos.lock.core.reentrant.AtomicLockService;
import com.alibaba.nacos.lock.model.LockKey;
import com.alibaba.nacos.sys.utils.DiskUtils;
import com.alibaba.nacos.sys.utils.TimerContext;
import com.alipay.sofa.jraft.util.CRC64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Paths;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.function.BiConsumer;
import java.util.zip.Checksum;
/**
* nacosLock snapshot handler.
*
* @author 985492783@qq.com
* @date 2023/9/7 20:42
*/
public class NacosLockSnapshotOperation implements SnapshotOperation {
protected static final String CHECK_SUM_KEY = "checksum";
private final ReentrantReadWriteLock.WriteLock writeLock;
private final LockManager lockManager;
private static final Logger LOGGER = LoggerFactory.getLogger(NacosLockSnapshotOperation.class);
private static final String LOCK_SNAPSHOT_SAVE = NacosLockSnapshotOperation.class.getSimpleName() + ".SAVE";
private static final String LOCK_SNAPSHOT_LOAD = NacosLockSnapshotOperation.class.getSimpleName() + ".LOAD";
private final Serializer serializer = SerializeFactory.getDefault();
private static final String SNAPSHOT_ARCHIVE = "nacos_lock.zip";
public NacosLockSnapshotOperation(LockManager lockManager, ReentrantReadWriteLock.WriteLock writeLock) {
this.lockManager = lockManager;
this.writeLock = writeLock;
}
@Override
public void onSnapshotSave(Writer writer, BiConsumer<Boolean, Throwable> callFinally) {
RaftExecutor.doSnapshot(() -> {
TimerContext.start(getSnapshotSaveTag());
final Lock lock = writeLock;
lock.lock();
try {
callFinally.accept(writeSnapshot(writer), null);
} catch (Throwable t) {
Loggers.RAFT.error("Fail to compress snapshot, path={}, file list={}.", writer.getPath(),
writer.listFiles(), t);
callFinally.accept(false, t);
} finally {
lock.unlock();
TimerContext.end(getSnapshotSaveTag(), Loggers.RAFT);
}
});
}
private boolean writeSnapshot(Writer writer) throws IOException {
final String writePath = writer.getPath();
final String outputFile = Paths.get(writePath, SNAPSHOT_ARCHIVE).toString();
final Checksum checksum = new CRC64();
try (InputStream inputStream = dumpSnapshot()) {
DiskUtils.compressIntoZipFile("lock", inputStream, outputFile, checksum);
}
final LocalFileMeta meta = new LocalFileMeta();
meta.append(CHECK_SUM_KEY, Long.toHexString(checksum.getValue()));
return writer.addFile(SNAPSHOT_ARCHIVE, meta);
}
private InputStream dumpSnapshot() {
ConcurrentHashMap<LockKey, AtomicLockService> lockMap = lockManager.showLocks();
return new ByteArrayInputStream(serializer.serialize(lockMap));
}
@Override
public boolean onSnapshotLoad(Reader reader) {
TimerContext.start(getSnapshotLoadTag());
final Lock lock = writeLock;
lock.lock();
try {
return readSnapshot(reader);
} catch (final Throwable t) {
Loggers.RAFT.error("Fail to load snapshot, path={}, file list={}.", reader.getPath(), reader.listFiles(),
t);
return false;
} finally {
lock.unlock();
TimerContext.end(getSnapshotLoadTag(), Loggers.RAFT);
}
}
private boolean readSnapshot(Reader reader) throws Exception {
final String readerPath = reader.getPath();
Loggers.RAFT.info("snapshot start to load from : {}", readerPath);
final String sourceFile = Paths.get(readerPath, SNAPSHOT_ARCHIVE).toString();
final Checksum checksum = new CRC64();
byte[] snapshotBytes = DiskUtils.decompress(sourceFile, checksum);
LocalFileMeta fileMeta = reader.getFileMeta(SNAPSHOT_ARCHIVE);
if (fileMeta.getFileMeta().containsKey(CHECK_SUM_KEY) && !Objects.equals(Long.toHexString(checksum.getValue()),
fileMeta.get(CHECK_SUM_KEY))) {
throw new IllegalArgumentException("Snapshot checksum failed");
}
loadSnapshot(snapshotBytes);
Loggers.RAFT.info("snapshot success to load from : {}", readerPath);
return true;
}
private void loadSnapshot(byte[] snapshotBytes) {
ConcurrentHashMap<LockKey, AtomicLockService> newData = serializer.deserialize(snapshotBytes);
ConcurrentHashMap<LockKey, AtomicLockService> lockMap = lockManager.showLocks();
//loadSnapshot
lockMap.putAll(newData);
}
protected String getSnapshotSaveTag() {
return LOCK_SNAPSHOT_SAVE;
}
protected String getSnapshotLoadTag() {
return LOCK_SNAPSHOT_LOAD;
}
}

42
lock/src/main/java/com/alibaba/nacos/lock/raft/request/MutexLockRequest.java Normal file
View File

@ -0,0 +1,42 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock.raft.request;
import com.alibaba.nacos.lock.model.LockInfo;
import java.io.Serializable;
/**
* mutex lock request.
*
* @author 985492783@qq.com
* @date 2023/8/24 18:40
*/
public class MutexLockRequest implements Serializable {
private static final long serialVersionUID = -925543547156890549L;
private LockInfo lockInfo;
public LockInfo getLockInfo() {
return lockInfo;
}
public void setLockInfo(LockInfo lockInfo) {
this.lockInfo = lockInfo;
}
}

70
lock/src/main/java/com/alibaba/nacos/lock/remote/rpc/handler/LockRequestHandler.java Normal file
View File

@ -0,0 +1,70 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock.remote.rpc.handler;
import com.alibaba.nacos.api.exception.NacosException;
import com.alibaba.nacos.api.lock.model.LockInstance;
import com.alibaba.nacos.api.lock.remote.LockOperationEnum;
import com.alibaba.nacos.api.lock.remote.request.LockOperationRequest;
import com.alibaba.nacos.api.lock.remote.response.LockOperationResponse;
import com.alibaba.nacos.api.remote.request.RequestMeta;
import com.alibaba.nacos.auth.annotation.Secured;
import com.alibaba.nacos.core.remote.RequestHandler;
import com.alibaba.nacos.lock.exception.NacosLockException;
import com.alibaba.nacos.lock.service.LockOperationService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
/**
* lock grpc handler.
*
* @author 985492783@qq.com
* @description LockRequestHandler
* @date 2023/6/29 14:00
*/
@Component
public class LockRequestHandler extends RequestHandler<LockOperationRequest, LockOperationResponse> {
private static final Logger LOGGER = LoggerFactory.getLogger(LockRequestHandler.class);
private final LockOperationService lockOperationService;
public LockRequestHandler(LockOperationService lockOperationService) {
this.lockOperationService = lockOperationService;
}
@Override
@Secured(resource = "grpc/lock")
public LockOperationResponse handle(LockOperationRequest request, RequestMeta meta) throws NacosException {
Boolean lock = null;
LOGGER.info("request: {}, instance: {}", request.getLockOperationEnum(), request.getLockInstance());
try {
if (request.getLockOperationEnum() == LockOperationEnum.ACQUIRE) {
LockInstance lockInstance = request.getLockInstance();
lock = lockOperationService.lock(lockInstance);
} else if (request.getLockOperationEnum() == LockOperationEnum.RELEASE) {
lock = lockOperationService.unLock(request.getLockInstance());
} else {
return LockOperationResponse.fail("There is no Handler of such operations!");
}
return LockOperationResponse.success(lock);
} catch (NacosLockException e) {
return LockOperationResponse.fail(e.getMessage());
}
}
}

45
lock/src/main/java/com/alibaba/nacos/lock/service/LockOperationService.java Normal file
View File

@ -0,0 +1,45 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock.service;
import com.alibaba.nacos.api.lock.model.LockInstance;
/**
* lock operator service.
*
* @author 985492783@qq.com
* @date 2023/6/28 2:38
*/
public interface LockOperationService {
/**
* get lock operator.
*
* @param lockInstance lockInstance
* @return boolean
*/
Boolean lock(LockInstance lockInstance);
/**
* unLock.
*
* @param lockInstance lockInstance
* @return Boolean
*/
Boolean unLock(LockInstance lockInstance);
}

209
lock/src/main/java/com/alibaba/nacos/lock/service/impl/LockOperationServiceImpl.java Normal file
View File

@ -0,0 +1,209 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock.service.impl;
import com.alibaba.nacos.api.lock.model.LockInstance;
import com.alibaba.nacos.api.lock.remote.LockOperationEnum;
import com.alibaba.nacos.consistency.SerializeFactory;
import com.alibaba.nacos.consistency.Serializer;
import com.alibaba.nacos.consistency.cp.CPProtocol;
import com.alibaba.nacos.consistency.cp.RequestProcessor4CP;
import com.alibaba.nacos.consistency.entity.ReadRequest;
import com.alibaba.nacos.consistency.entity.Response;
import com.alibaba.nacos.consistency.entity.WriteRequest;
import com.alibaba.nacos.consistency.snapshot.SnapshotOperation;
import com.alibaba.nacos.core.distributed.ProtocolManager;
import com.alibaba.nacos.lock.LockManager;
import com.alibaba.nacos.lock.constant.Constants;
import com.alibaba.nacos.lock.constant.PropertiesConstant;
import com.alibaba.nacos.lock.core.reentrant.AtomicLockService;
import com.alibaba.nacos.lock.exception.NacosLockException;
import com.alibaba.nacos.lock.model.LockInfo;
import com.alibaba.nacos.lock.model.LockKey;
import com.alibaba.nacos.lock.persistence.NacosLockSnapshotOperation;
import com.alibaba.nacos.lock.raft.request.MutexLockRequest;
import com.alibaba.nacos.lock.service.LockOperationService;
import com.alibaba.nacos.sys.env.EnvUtil;
import com.alibaba.nacos.sys.utils.ApplicationUtils;
import com.google.protobuf.ByteString;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* lock operation and CPHandler.
*
* @author 985492783@qq.com
* @date 2023/8/22 20:17
*/
@Component
public class LockOperationServiceImpl extends RequestProcessor4CP implements LockOperationService {
private static final Logger LOGGER = LoggerFactory.getLogger(LockOperationServiceImpl.class);
private final Serializer serializer = SerializeFactory.getDefault();
private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
private final ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
private final CPProtocol protocol;
private final LockManager lockManager;
private final long defaultExpireTime;
private final long maxExpireTime;
public LockOperationServiceImpl(LockManager lockManager) {
this.lockManager = lockManager;
this.protocol = ApplicationUtils.getBean(ProtocolManager.class).getCpProtocol();
this.protocol.addRequestProcessors(Collections.singletonList(this));
this.defaultExpireTime = EnvUtil.getProperty(PropertiesConstant.DEFAULT_AUTO_EXPIRE, Long.class,
PropertiesConstant.DEFAULT_AUTO_EXPIRE_TIME);
this.maxExpireTime = EnvUtil.getProperty(PropertiesConstant.MAX_AUTO_EXPIRE, Long.class,
PropertiesConstant.MAX_AUTO_EXPIRE_TIME);
}
@Override
public Response onApply(WriteRequest request) {
final Lock lock = readLock;
lock.lock();
try {
LockOperationEnum lockOperation = LockOperationEnum.valueOf(request.getOperation());
Object data = null;
if (lockOperation == LockOperationEnum.ACQUIRE) {
final MutexLockRequest mutexLockRequest = serializer.deserialize(request.getData().toByteArray());
data = acquireLock(mutexLockRequest);
} else if (lockOperation == LockOperationEnum.RELEASE) {
final MutexLockRequest mutexLockRequest = serializer.deserialize(request.getData().toByteArray());
data = releaseLock(mutexLockRequest);
} else {
throw new NacosLockException("lockOperation is not exist.");
}
LOGGER.info("thread: {}, operator: {}, request: {}, success: {}", Thread.currentThread().getName(),
lockOperation, serializer.deserialize(request.getData().toByteArray()), data);
ByteString bytes = ByteString.copyFrom(serializer.serialize(data));
return Response.newBuilder().setSuccess(true).setData(bytes).build();
} catch (NacosLockException e) {
return Response.newBuilder().setSuccess(false).setErrMsg(e.getMessage()).build();
} finally {
lock.unlock();
}
}
private Boolean releaseLock(MutexLockRequest request) {
LockInfo lockInfo = request.getLockInfo();
AtomicLockService mutexLock = lockManager.getMutexLock(lockInfo.getKey());
Boolean unLock = mutexLock.unLock(lockInfo);
if (mutexLock.isClear()) {
lockManager.removeMutexLock(lockInfo.getKey());
}
return unLock;
}
private Boolean acquireLock(MutexLockRequest request) {
LockInfo lockInfo = request.getLockInfo();
AtomicLockService mutexLock = lockManager.getMutexLock(lockInfo.getKey());
return mutexLock.tryLock(lockInfo);
}
@Override
public Boolean lock(LockInstance lockInstance) {
final MutexLockRequest request = new MutexLockRequest();
final LockInfo lockInfo = new LockInfo();
lockInfo.setKey(new LockKey(lockInstance.getLockType(), lockInstance.getKey()));
lockInfo.setParams(lockInstance.getParams());
long expiredTime = lockInstance.getExpiredTime();
if (expiredTime < 0) {
lockInfo.setEndTime(defaultExpireTime + getNowTimestamp());
} else {
lockInfo.setEndTime(Math.min(maxExpireTime, expiredTime) + getNowTimestamp());
}
request.setLockInfo(lockInfo);
WriteRequest writeRequest = WriteRequest.newBuilder().setGroup(group())
.setData(ByteString.copyFrom(serializer.serialize(request)))
.setOperation(LockOperationEnum.ACQUIRE.name()).build();
try {
Response response = protocol.write(writeRequest);
if (response.getSuccess()) {
return serializer.deserialize(response.getData().toByteArray());
}
throw new NacosLockException(response.getErrMsg());
} catch (NacosLockException e) {
int paramSize = lockInstance.getParams() == null ? 0 : lockInstance.getParams().size();
LOGGER.error("key: {}, lockType:{}, paramSize:{} lock fail, errorMsg: {}", lockInstance.getKey(),
lockInstance.getLockType(), paramSize, e.getMessage());
throw e;
} catch (Exception e) {
LOGGER.error("lock fail.", e);
throw new NacosLockException("tryLock error.", e);
}
}
@Override
public List<SnapshotOperation> loadSnapshotOperate() {
return Collections.singletonList(new NacosLockSnapshotOperation(lockManager, lock.writeLock()));
}
@Override
public Boolean unLock(LockInstance lockInstance) {
MutexLockRequest request = new MutexLockRequest();
LockInfo lockInfo = new LockInfo();
lockInfo.setKey(new LockKey(lockInstance.getLockType(), lockInstance.getKey()));
lockInfo.setParams(lockInstance.getParams());
request.setLockInfo(lockInfo);
WriteRequest writeRequest = WriteRequest.newBuilder().setGroup(group())
.setData(ByteString.copyFrom(serializer.serialize(request)))
.setOperation(LockOperationEnum.RELEASE.name()).build();
try {
Response response = protocol.write(writeRequest);
if (response.getSuccess()) {
return serializer.deserialize(response.getData().toByteArray());
}
throw new NacosLockException(response.getErrMsg());
} catch (NacosLockException e) {
int paramSize = lockInstance.getParams() == null ? 0 : lockInstance.getParams().size();
LOGGER.error("key: {}, lockType:{}, paramSize:{} lock fail, errorMsg: {}", lockInstance.getKey(),
lockInstance.getLockType(), paramSize, e.getMessage());
throw e;
} catch (Exception e) {
throw new NacosLockException("unLock error.", e);
}
}
public long getNowTimestamp() {
return System.currentTimeMillis();
}
@Override
public Response onRequest(ReadRequest request) {
return null;
}
@Override
public String group() {
return Constants.LOCK_ACQUIRE_SERVICE_GROUP_V2;
}
}

17
lock/src/main/resources/META-INF/services/com.alibaba.nacos.lock.factory.LockFactory Normal file
View File

@ -0,0 +1,17 @@
#
# Copyright 1999-2023 Alibaba Group Holding Ltd.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
com.alibaba.nacos.lock.factory.SimpleLockFactory

87
lock/src/test/java/com/alibaba/nacos/lock/LockManagerTest.java Normal file
View File

@ -0,0 +1,87 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock;
import com.alibaba.nacos.lock.core.reentrant.AtomicLockService;
import com.alibaba.nacos.lock.core.reentrant.mutex.ClientAtomicLock;
import com.alibaba.nacos.lock.exception.NacosLockException;
import com.alibaba.nacos.lock.factory.ClientLockFactory;
import com.alibaba.nacos.lock.factory.LockFactory;
import com.alibaba.nacos.lock.model.LockInfo;
import com.alibaba.nacos.lock.model.LockKey;
import org.junit.jupiter.api.Test;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* lock manager test.
*
* @author 985492783@qq.com
* @date 2023/8/28 13:26
*/
public class LockManagerTest {
private LockManager lockManager = new NacosLockManager();
@Test
public void testLockManagerError() {
String emptyType = "testLockFactory_lock";
assertThrows(NacosLockException.class, () -> {
lockManager.getMutexLock(new LockKey(emptyType, "key"));
});
assertThrows(NacosLockException.class, () -> {
lockManager.getMutexLock(new LockKey(emptyType, null));
});
assertThrows(NacosLockException.class, () -> {
lockManager.getMutexLock(new LockKey(null, "key"));
});
}
@Test
public void testLockFactory() throws NoSuchFieldException, IllegalAccessException {
Field factoryMap = NacosLockManager.class.getDeclaredField("factoryMap");
factoryMap.setAccessible(true);
Map<String, LockFactory> map = (Map<String, LockFactory>) factoryMap.get(lockManager);
assertEquals(2, map.size());
}
@Test
public void testClientLockFactory() {
AtomicLockService lock = lockManager.getMutexLock(new LockKey(ClientLockFactory.TYPE, "key"));
assertEquals(ClientAtomicLock.class, lock.getClass());
assertEquals("key", lock.getKey());
LockInfo lockInfo = new ClientLockFactory.ClientLockInstance();
lockInfo.setParams(new HashMap() {
{
put("nacosClientId", "123456");
}
});
assertTrue(lock.tryLock(lockInfo));
assertTrue(lock.tryLock(lockInfo));
assertTrue(lock.unLock(lockInfo));
}
}

67
lock/src/test/java/com/alibaba/nacos/lock/core/reentrant/mutex/ClientAtomicLock.java Normal file
View File

@ -0,0 +1,67 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock.core.reentrant.mutex;
import com.alibaba.nacos.lock.core.reentrant.AbstractAtomicLock;
import com.alibaba.nacos.lock.model.LockInfo;
import java.util.concurrent.atomic.AtomicReference;
/**
* use clientId to get lock.
*
* @author 985492783@qq.com
* @date 2023/8/30 1:02
*/
public class ClientAtomicLock extends AbstractAtomicLock {
private static final String EMPTY = null;
private final AtomicReference<String> state;
private Long expireTimestamp;
public ClientAtomicLock(String key) {
super(key);
this.state = new AtomicReference<>(EMPTY);
}
@Override
public Boolean tryLock(LockInfo lockInfo) {
String nacosClientId = (String) lockInfo.getParams().get("nacosClientId");
if (nacosClientId == null) {
return false;
}
return state.compareAndSet(EMPTY, nacosClientId) || state.get().equals(nacosClientId);
}
@Override
public Boolean unLock(LockInfo lockInfo) {
String nacosClientId = (String) lockInfo.getParams().get("nacosClientId");
return state.compareAndSet(nacosClientId, EMPTY);
}
@Override
public Boolean autoExpire() {
return System.currentTimeMillis() >= this.expireTimestamp;
}
@Override
public Boolean isClear() {
return state.get() == null || autoExpire();
}
}

71
lock/src/test/java/com/alibaba/nacos/lock/core/reentrant/mutex/MutexAtomicLockTest.java Normal file
View File

@ -0,0 +1,71 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock.core.reentrant.mutex;
import com.alibaba.nacos.api.lock.common.LockConstants;
import com.alibaba.nacos.lock.LockManager;
import com.alibaba.nacos.lock.core.reentrant.AtomicLockService;
import com.alibaba.nacos.lock.model.LockInfo;
import com.alibaba.nacos.lock.model.LockKey;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* mutex atomic lock test.
*
* @author 985492783@qq.com
* @date 2023/8/28 13:13
*/
@ExtendWith(MockitoExtension.class)
public class MutexAtomicLockTest {
@Mock
private LockManager lockManager;
@Test
public void testLockAndUnlock() {
Mockito.when(lockManager.getMutexLock(Mockito.any())).thenReturn(new MutexAtomicLock("key"));
AtomicLockService lock = lockManager.getMutexLock(new LockKey(LockConstants.NACOS_LOCK_TYPE, "key"));
LockInfo lockInfo = new LockInfo();
lockInfo.setEndTime(System.currentTimeMillis() + 2_000_000);
assertTrue(lock.tryLock(lockInfo));
assertTrue(lock.unLock(lockInfo));
}
@Test
public void testAutoExpire() {
Mockito.when(lockManager.getMutexLock(Mockito.any()))
.thenReturn(new MutexAtomicLock("key"));
AtomicLockService lock = lockManager.getMutexLock(new LockKey(LockConstants.NACOS_LOCK_TYPE, "key"));
LockInfo lockInfo = new LockInfo();
lockInfo.setEndTime(System.currentTimeMillis() - 2_000_000);
assertTrue(lock.tryLock(lockInfo));
assertTrue(lock.autoExpire());
LockInfo lockInstanceAuto = new LockInfo();
lockInstanceAuto.setEndTime(System.currentTimeMillis() + 2_000_000);
assertTrue(lock.tryLock(lockInstanceAuto));
}
}

46
lock/src/test/java/com/alibaba/nacos/lock/factory/ClientLockFactory.java Normal file
View File

@ -0,0 +1,46 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock.factory;
import com.alibaba.nacos.lock.core.reentrant.AbstractAtomicLock;
import com.alibaba.nacos.lock.core.reentrant.mutex.ClientAtomicLock;
import com.alibaba.nacos.lock.model.LockInfo;
/**
* create clientLock.
*
* @author 985492783@qq.com
* @date 2023/8/30 0:59
*/
public class ClientLockFactory implements LockFactory {
public static final String TYPE = "CLIENT_LOCK_TYPE";
@Override
public String getLockType() {
return TYPE;
}
@Override
public AbstractAtomicLock createLock(String key) {
return new ClientAtomicLock(key);
}
public static class ClientLockInstance extends LockInfo {
}
}

73
lock/src/test/java/com/alibaba/nacos/lock/remote/rpc/handler/LockRequestHandlerTest.java Normal file
View File

@ -0,0 +1,73 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock.remote.rpc.handler;
import com.alibaba.nacos.api.exception.NacosException;
import com.alibaba.nacos.api.lock.common.LockConstants;
import com.alibaba.nacos.api.lock.model.LockInstance;
import com.alibaba.nacos.api.lock.remote.LockOperationEnum;
import com.alibaba.nacos.api.lock.remote.request.LockOperationRequest;
import com.alibaba.nacos.api.lock.remote.response.LockOperationResponse;
import com.alibaba.nacos.lock.service.LockOperationService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* lockRequest handler test.
*
* @author 985492783@qq.com
* @date 2023/9/1 10:00
*/
@ExtendWith(MockitoExtension.class)
public class LockRequestHandlerTest {
@Mock
private LockOperationService lockOperationService;
private LockRequestHandler lockRequestHandler;
@Test
public void testAcquireHandler() throws NacosException {
lockRequestHandler = new LockRequestHandler(lockOperationService);
LockInstance lockInstance = new LockInstance("key", 1L, LockConstants.NACOS_LOCK_TYPE);
LockOperationRequest request = new LockOperationRequest();
request.setLockInstance(lockInstance);
request.setLockOperationEnum(LockOperationEnum.ACQUIRE);
Mockito.when(lockOperationService.lock(lockInstance)).thenReturn(true);
LockOperationResponse response = lockRequestHandler.handle(request, null);
assertTrue((Boolean) response.getResult());
}
@Test
public void testReleaseHandler() throws NacosException {
lockRequestHandler = new LockRequestHandler(lockOperationService);
LockInstance lockInstance = new LockInstance("key", 1L, LockConstants.NACOS_LOCK_TYPE);
LockOperationRequest request = new LockOperationRequest();
request.setLockInstance(lockInstance);
request.setLockOperationEnum(LockOperationEnum.RELEASE);
Mockito.when(lockOperationService.unLock(lockInstance)).thenReturn(true);
LockOperationResponse response = lockRequestHandler.handle(request, null);
assertTrue((Boolean) response.getResult());
}
}

194
lock/src/test/java/com/alibaba/nacos/lock/service/impl/LockOperationServiceImplTest.java Normal file
View File

@ -0,0 +1,194 @@
/*
* Copyright 1999-2023 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.nacos.lock.service.impl;
import com.alibaba.nacos.api.lock.common.LockConstants;
import com.alibaba.nacos.api.lock.model.LockInstance;
import com.alibaba.nacos.api.lock.remote.LockOperationEnum;
import com.alibaba.nacos.consistency.SerializeFactory;
import com.alibaba.nacos.consistency.Serializer;
import com.alibaba.nacos.consistency.cp.CPProtocol;
import com.alibaba.nacos.consistency.entity.Response;
import com.alibaba.nacos.consistency.entity.WriteRequest;
import com.alibaba.nacos.core.distributed.ProtocolManager;
import com.alibaba.nacos.lock.LockManager;
import com.alibaba.nacos.lock.constant.PropertiesConstant;
import com.alibaba.nacos.lock.core.reentrant.mutex.MutexAtomicLock;
import com.alibaba.nacos.lock.model.LockInfo;
import com.alibaba.nacos.lock.model.LockKey;
import com.alibaba.nacos.lock.raft.request.MutexLockRequest;
import com.alibaba.nacos.sys.env.EnvUtil;
import com.alibaba.nacos.sys.utils.ApplicationUtils;
import com.google.protobuf.ByteString;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.function.BooleanSupplier;
import static com.alibaba.nacos.lock.constant.Constants.LOCK_ACQUIRE_SERVICE_GROUP_V2;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* lock operation service test.
*
* @author 985492783@qq.com
* @date 2023/8/30 14:01
*/
@ExtendWith(MockitoExtension.class)
public class LockOperationServiceImplTest {
@Mock
private ProtocolManager protocolManager;
@Mock
private static CPProtocol cpProtocol;
@Mock
private static LockManager lockManager;
private final Serializer serializer = SerializeFactory.getDefault();
private LockOperationServiceImpl lockOperationService;
private static MockedStatic<ApplicationUtils> mockedStatic;
private static MockedStatic<EnvUtil> mockedEnv;
@BeforeAll
public static void setUp() {
mockedStatic = Mockito.mockStatic(ApplicationUtils.class);
mockedEnv = Mockito.mockStatic(EnvUtil.class);
mockedEnv.when(() -> EnvUtil.getProperty(Mockito.any(), Mockito.any(), Mockito.any()))
.thenAnswer(ins -> ins.getArgument(2));
}
/**
* build test service.
*/
public void buildService() {
mockedStatic.when(() -> ApplicationUtils.getBean(ProtocolManager.class)).thenReturn(protocolManager);
Mockito.when(protocolManager.getCpProtocol()).thenReturn(cpProtocol);
lockOperationService = Mockito.spy(new LockOperationServiceImpl(lockManager));
}
@Test
public void testGroup() {
buildService();
assertEquals(lockOperationService.group(), LOCK_ACQUIRE_SERVICE_GROUP_V2);
}
@Test
public void testLockExpire() throws Exception {
buildService();
long timestamp = 1 << 10;
Mockito.when(lockOperationService.getNowTimestamp()).thenReturn(timestamp);
Mockito.when(cpProtocol.write(Mockito.any())).thenAnswer((i) -> {
WriteRequest request = i.getArgument(0);
MutexLockRequest mutexLockRequest = serializer.deserialize(request.getData().toByteArray());
LockInfo lockInfo = mutexLockRequest.getLockInfo();
assertEquals(LockConstants.NACOS_LOCK_TYPE, lockInfo.getKey().getLockType());
assertEquals(timestamp + PropertiesConstant.DEFAULT_AUTO_EXPIRE_TIME, (long) lockInfo.getEndTime());
return getResponse();
});
LockInstance lockInstance = new LockInstance("key", -1L, LockConstants.NACOS_LOCK_TYPE);
lockOperationService.lock(lockInstance);
}
@Test
public void testLockSimple() throws Exception {
buildService();
long timestamp = 1 << 10;
Mockito.when(lockOperationService.getNowTimestamp()).thenReturn(timestamp);
Mockito.when(cpProtocol.write(Mockito.any())).thenAnswer((i) -> {
WriteRequest request = i.getArgument(0);
MutexLockRequest mutexLockRequest = serializer.deserialize(request.getData().toByteArray());
LockInfo lockInfo = mutexLockRequest.getLockInfo();
assertEquals(lockInfo.getKey().getLockType(), LockConstants.NACOS_LOCK_TYPE);
assertEquals((long) lockInfo.getEndTime(), timestamp + 1_000L);
return getResponse();
});
LockInstance lockInstance = new LockInstance("key", 1_000L, LockConstants.NACOS_LOCK_TYPE);
lockOperationService.lock(lockInstance);
}
@Test
public void testLockMaxExpire() throws Exception {
buildService();
long timestamp = 1 << 10;
Mockito.when(lockOperationService.getNowTimestamp()).thenReturn(timestamp);
Mockito.when(cpProtocol.write(Mockito.any())).thenAnswer((i) -> {
WriteRequest request = i.getArgument(0);
MutexLockRequest mutexLockRequest = serializer.deserialize(request.getData().toByteArray());
LockInfo lockInfo = mutexLockRequest.getLockInfo();
assertEquals(lockInfo.getKey().getLockType(), LockConstants.NACOS_LOCK_TYPE);
assertEquals((long) lockInfo.getEndTime(), timestamp + PropertiesConstant.MAX_AUTO_EXPIRE_TIME);
return getResponse();
});
LockInstance lockInstance = new LockInstance("key", PropertiesConstant.MAX_AUTO_EXPIRE_TIME + 1_000L,
LockConstants.NACOS_LOCK_TYPE);
lockOperationService.lock(lockInstance);
}
@Test
public void testOnApply() {
buildService();
Mockito.when(lockManager.getMutexLock(new LockKey(LockConstants.NACOS_LOCK_TYPE, "key")))
.thenReturn(new MutexAtomicLock("key"));
WriteRequest request = getRequest(LockOperationEnum.ACQUIRE);
Response response = lockOperationService.onApply(request);
assertTrue(response.getSuccess());
assertTrue(serializer.<Boolean>deserialize(response.getData().toByteArray()));
}
public WriteRequest getRequest(LockOperationEnum lockOperationEnum) {
MutexLockRequest mutexLockRequest = new MutexLockRequest();
LockInfo lockInfo = new LockInfo();
lockInfo.setEndTime(1L + System.currentTimeMillis());
lockInfo.setKey(new LockKey(LockConstants.NACOS_LOCK_TYPE, "key"));
mutexLockRequest.setLockInfo(lockInfo);
WriteRequest writeRequest = WriteRequest.newBuilder().setGroup(lockOperationService.group())
.setData(ByteString.copyFrom(serializer.serialize(mutexLockRequest)))
.setOperation(lockOperationEnum.name()).build();
return writeRequest;
}
public Response getResponse() {
return Response.newBuilder().setSuccess(true).setData(ByteString.copyFrom(serializer.serialize(true))).build();
}
@AfterAll
public static void destroy() {
mockedStatic.close();
mockedEnv.close();
}
}

17
lock/src/test/resources/META-INF/services/com.alibaba.nacos.lock.factory.LockFactory Normal file
View File

@ -0,0 +1,17 @@
#
# Copyright 1999-2023 Alibaba Group Holding Ltd.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
com.alibaba.nacos.lock.factory.ClientLockFactory

2
plugin-default-impl/nacos-default-auth-plugin/src/main/java/com/alibaba/nacos/plugin/auth/impl/constant/AuthConstants.java
View File

@ -45,6 +45,8 @@ public class AuthConstants {
public static final String UPDATE_PASSWORD_ENTRY_POINT = CONSOLE_RESOURCE_NAME_PREFIX + "user/password";
public static final String LOCK_OPERATOR_POINT = "grpc/lock";
public static final String NACOS_USER_KEY = "nacosuser";
public static final String TOKEN_SECRET_KEY = "nacos.core.auth.plugin.nacos.token.secret.key";

12
plugin-default-impl/nacos-default-auth-plugin/src/main/java/com/alibaba/nacos/plugin/auth/impl/roles/NacosRoleServiceImpl.java
View File

@ -60,6 +60,8 @@ public class NacosRoleServiceImpl {
private static final int DEFAULT_PAGE_NO = 1;
private static final Set<String> WHITE_PERMISSION = new HashSet<>();
@Autowired
private AuthConfigs authConfigs;
@ -78,6 +80,11 @@ public class NacosRoleServiceImpl {
private volatile Map<String, List<PermissionInfo>> permissionInfoMap = new ConcurrentHashMap<>();
static {
WHITE_PERMISSION.add(AuthConstants.UPDATE_PASSWORD_ENTRY_POINT);
WHITE_PERMISSION.add(AuthConstants.LOCK_OPERATOR_POINT);
}
@Scheduled(initialDelay = 5000, fixedDelay = 15000)
private void reload() {
try {
@ -122,6 +129,11 @@ public class NacosRoleServiceImpl {
* @return true if granted, false otherwise
*/
public boolean hasPermission(NacosUser nacosUser, Permission permission) {
//white permission
if (WHITE_PERMISSION.contains(permission.getResource().getName())) {
return true;
}
if (isUpdatePasswordPermission(permission)) {
return true;
}

11
plugin/auth/src/main/java/com/alibaba/nacos/plugin/auth/api/RequestResource.java
View File

@ -94,6 +94,17 @@ public class RequestResource {
return result;
}
/**
* Create new lock request resource builder.
*
* @return lock request resource builder
*/
public static Builder lockBuilder() {
Builder result = new Builder();
result.setType(SignType.LOCK);
return result;
}
public static class Builder {
private String type;

2
plugin/auth/src/main/java/com/alibaba/nacos/plugin/auth/constant/SignType.java
View File

@ -27,6 +27,8 @@ public class SignType {
public static final String CONFIG = "config";
public static final String LOCK = "lock";
public static final String CONSOLE = "console";
public static final String SPECIFIED = "specified";

9
pom.xml
View File

@ -88,7 +88,7 @@
</issueManagement>
<properties>
<revision>3.0.0-ALPHA</revision>
<revision>3.0.0-ALPHA-SNAPSHOT</revision>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<!-- Compiler settings properties -->
@ -625,10 +625,12 @@
<module>k8s-sync</module>
<module>bootstrap</module>
<module>server</module>
<module>lock</module>
</modules>
<!-- Default dependencies in all subprojects -->
<dependencies>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
@ -739,6 +741,11 @@
<artifactId>nacos-core</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>nacos-lock</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>com.alibaba.nacos</groupId>
<artifactId>nacos-persistence</artifactId>