OpenStack4j 多线程编程session问题（一）

背景

项目中使用了 OpenStack4j github链接来调用 OpenStack 接口，最近负责实现一个“自动化构建上百个虚拟节点”功能，觉得单线程模式下一个个创虚拟机太慢了，考虑使用多线程的方式创建虚拟机，创建过程中遇到了如下异常：

# org.openstack4j.api.exceptions.OS4JException: 
# Unable to retrieve current session. 
# Please verify thread has a current session available.

从字面上，是说我当前的线程没有对应的会话（session），那么这个会话到底是怎么回事呢？如何用多线程实现对 OpenStack 的并发请求呢？下面就来说一说

错误还原

使用 OpenStack4j 创建虚拟机的代码很简单，分两步走，第一步，建立一个 client，第二步，用 client 获取 compute 服务并创建虚拟机，代码示范如下：

第一步，建立一个 client：

OSClientV3 os = OSFactory.builderV3()
                .endpoint("http://:5000/v3")
                .credentials("admin", "secret", Identifier.byId("user domain id"))
                .scopeToProject(Identifier.byId("project id"))
                .authenticate());

第二步，获取 compute服务并创建虚拟机，这里的server就是创建的虚拟机：

ServerCreate serverCreate = Builders.server()
                .name(name)
                .addSecurityGroup(securityGroup)
                .flavor(flavorId)
                .image(imageId)
                .networks(networks)
                .keypairName(keypairName)
                .build();
Server server = os.compute().servers().boot(serverCreate);

那么用多线程创建虚拟机的代码结构就大致如下，当然，只是简单的示范代码：

OSClientV3 os = OSFactory.builderV3()
                .endpoint("http://:5000/v3")
                .credentials("admin", "secret", Identifier.byId("user domain id"))
                .scopeToProject(Identifier.byId("project id"))
                .authenticate());

//用线程池管理线程
ExecutorService executorService = Executors.newFixedThreadPool(THREAD_COUNT);

for(int i = 0; i < n; i++) {
    executorService.submit(new createMission(os));
}

executorService.shutdown();

//创建一个任务类，继承线程
class CreateMission extends Thread {

    OSClientV3 os;
     
    public CreateMission(OSClientV3 os) {
        this.os = os;   
    }

    @Override
    public void run() {
        //创建serverCreate对象，这里省略代码
        Server server = os.compute().servers().boot(serverCreate);
    }
}

如果这么写的话，就报错啦，遇到上文所述的 session 异常：

# org.openstack4j.api.exceptions.OS4JException: 
# Unable to retrieve current session. 
# Please verify thread has a current session available.

为了解决这个错误，我们就得知道 session 是什么，为什么在多线程下会出错

Session

下面结合 OpenStack4j 源码来分析一下这个 session

说简单也简单，从 client 的创建说起：

OSClientV3 os = OSFactory.builderV3()
                .endpoint("http://:5000/v3")
                .credentials("admin", "secret", Identifier.byId("user domain id"))
                .scopeToProject(Identifier.byId("project id"))
                .authenticate());

如上所示，client 是用 OSFactory 的 builderV3 实现的，返回了一个ClientV3 对象：

package org.openstack4j.openstack;
public abstract class OSFactory> {
    ……
    public static V3 builderV3() {
        return new ClientV3();
    }
}

在创建 client 的一系列调用中， clientV3 对象最后调用了一个方法 authenticate()：

package org.openstack4j.openstack.client;
public abstract class OSClientBuilder {
    ……
    public static class ClientV3 extends OSClientBuilder {
        ……
        public OSClientV3 authenticate() throws AuthenticationException {
            if (this.tokenId != null && this.tokenId.length() > 0) {
                return this.scope != null ? (OSClientV3)OSAuthenticator.invoke(new KeystoneAuth(this.tokenId, this.scope), this.endpoint, this.perspective, this.config, this.provider) : (OSClientV3)OSAuthenticator.invoke(new KeystoneAuth(this.tokenId), this.endpoint, this.perspective, this.config, this.provider);
            } else {
                return this.user != null && this.user.length() > 0 ? (OSClientV3)OSAuthenticator.invoke(new KeystoneAuth(this.user, this.password, this.domain, this.scope), this.endpoint, this.perspective, this.config, this.provider) : (OSClientV3)OSAuthenticator.invoke(new KeystoneAuth(this.scope, Type.TOKENLESS), this.endpoint, this.perspective, this.config, this.provider);
            }
        }
    }
}

要注意 return 语句里调用了 OSAuthenticator.invoke 方法，这里面的实现如下：

package org.openstack4j.openstack.internal;
public class OSAuthenticator {
    ……
    public static OSClient invoke(KeystoneAuth auth, String endpoint, Facing perspective, Config config,
            CloudProvider provider) {
        SessionInfo info = new SessionInfo(endpoint, perspective, false, provider);
        return authenticateV3(auth, info, config);
    }
    
    private static OSClientV3 authenticateV3(KeystoneAuth auth, SessionInfo info, Config config) {
        ……
        if (!info.reLinkToExistingSession) {
            OSClientSessionV3 v3 = OSClientSessionV3.createSession(token, info.perspective, info.provider, config);
            v3.reqId = reqId;
            return v3;
        }

        OSClientSessionV3 current = (OSClientSessionV3) OSClientSessionV3.getCurrent();
        current.token = token;
       
        current.reqId = reqId;
        return current;
    }
}

注意看最后，这个方法返回了一个 OSClientSessionV3 的对象！所以说我们用的 client，其实就可以视为一个 session

以上介绍了那么多看似繁琐的调用，就是为了让我们形成这样一个理解：

在 OpenStack4j 里，创建的 client 可以被理解成创建了一次会话（session），以后的调用，都是基于此次会话的

最后看一下session类：

/**
 * A client which has been identified. Any calls spawned from this session will
 * automatically utilize the original authentication that was successfully
 * validated and authorized
 *
 * @author Jeremy Unruh
 */
public abstract class OSClientSession {
    private static final ThreadLocal sessions = new ThreadLocal();
    
    ……
    public static class OSClientSessionV3 extends OSClientSession {
        ……
    }
}

注意看一开始定义的 ThreadLocal sessions

谜底揭晓了，OSClientSession 用 ThreadLocal 为每个线程维护了一个 session(也就是client)

每次使用client调用某服务的时候，最后会调用到这里：

package org.openstack4j.openstack.internal;
public class BaseOpenStackService {
    ……
    @SuppressWarnings("rawtypes")
    private  Invocation builder(Class returnType, String path, HttpMethod method) {
        OSClientSession ses = OSClientSession.getCurrent();
        if (ses == null) {
            throw new OS4JException(
                    "Unable to retrieve current session. Please verify thread has a current session available.");
        }
        RequestBuilder req = HttpRequest.builder(returnType).endpointTokenProvider(ses).config(ses.getConfig())
                .method(method).path(path);
        Map headers = ses.getHeaders();
        if (headers != null && headers.size() > 0){
            return new Invocation(req, serviceType, endpointFunc).headers(headers);
        }else{ 
            return new Invocation(req, serviceType, endpointFunc);
        }
    }
}

上图里，着重看这段代码：

OSClientSession ses = OSClientSession.getCurrent();
if (ses == null) {
    throw new OS4JException(
            "Unable to retrieve current session. Please verify thread has a current session available.");
}

回顾一下之前多线程创建虚拟机的代码，我们在主线程里创建了 client (也可理解为会话)，在另外的线程里试图用这个会话调用 OpenStack 的服务，但这个会话是用 ThreadLocal 维护的，只属于主线程，另外的线程当然取不到这个会话，于是就报错啦

于是要使用多线程并发调用 OpenStack 的话，需要在每个线程里都创建一个会话，再进行调用，代码框架大概如下：

//用线程池管理线程
ExecutorService executorService = Executors.newFixedThreadPool(THREAD_COUNT);

for(int i = 0; i < n; i++) {
    executorService.submit(new createMission());
}

executorService.shutdown();

//创建一个任务类，继承线程
class CreateMission extends Thread {
     
    @Override
    public void run() {
        OSClientV3 os = OSFactory.builderV3()
                .endpoint("http://:5000/v3")
                .credentials("admin", "secret", Identifier.byId("user domain id"))
                .scopeToProject(Identifier.byId("project id"))
                .authenticate());
        //创建serverCreate对象，这里省略代码
        Server server = os.compute().servers().boot(serverCreate);
    }
}

但是！让我们假设一个场景，如果我要创建500个虚拟机，我用一个线程池，维护了若干个线程。每次，一个线程执行一次创建虚拟机的任务，就要创建一次会话，那么创建500个虚拟机，就需要创建500个会话！

这样对OpenStack服务器的压力是不是太大了？如果要创建1000个，1万个虚拟机呢？

既然我们用了线程池，复用了线程，我们是不是应该想办法把会话也复用一下？

这时候，就想到了利用 ThreadLocal，至于怎么用，下一篇再说了。

OpenStack4j 多线程编程session问题（一）

背景

错误还原

Session

你可能感兴趣的:(OpenStack4j 多线程编程session问题（一）)