美文网首页openstack云计算OpenStack
OpenStack4j 多线程编程session问题(一)

OpenStack4j 多线程编程session问题(一)

作者: Murray66 | 来源:发表于2019-04-17 19:40 被阅读27次

    背景

    项目中使用了 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://<fqdn>: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://<fqdn>: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://<fqdn>:5000/v3")
                    .credentials("admin", "secret", Identifier.byId("user domain id"))
                    .scopeToProject(Identifier.byId("project id"))
                    .authenticate());
    

    如上所示,client 是用 OSFactorybuilderV3 实现的,返回了一个ClientV3 对象:

    package org.openstack4j.openstack;
    public abstract class OSFactory<T extends OSFactory<T>> {
        ……
        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<OSClientSession> sessions = new ThreadLocal<OSClientSession>();
        
        ……
        public static class OSClientSessionV3 extends OSClientSession<OSClientSessionV3, OSClientV3> {
            ……
        }
    }
    

    注意看一开始定义的 ThreadLocal<OSClientSession> sessions

    谜底揭晓了,OSClientSessionThreadLocal<OSClientSession> 为每个线程维护了一个 session(也就是client)

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

    package org.openstack4j.openstack.internal;
    public class BaseOpenStackService {
        ……
        @SuppressWarnings("rawtypes")
        private <R> Invocation<R> builder(Class<R> 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<R> 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<R>(req, serviceType, endpointFunc).headers(headers);
            }else{ 
                return new Invocation<R>(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://<fqdn>: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问题(一)

        本文链接:https://www.haomeiwen.com/subject/qvlowqtx.html