Appium的实现理解

悠悠小仙仙

Appium的实现理解Appium的架构




起步

下载appium的源码，并安装依赖：

1. git clone https://github.com/appium/appium.git
   
2. npm install

复制代码

启动appium:node .

这个启动命令实际是执行的：node build\main.js(package.json中指定了main入口)：

1. ...
   
2. "main": "./build/lib/main.js",
   
3.   "bin": {
   
4.     "appium": "./build/lib/main.js"
   
5.   },
   
6. ...

复制代码

/build/main.js是由/lib/main.js经babel翻译后的结果，所以，我们来看下/lib/main.js来理解appium的流程。

(备注：由于appium源码执行都是执行的编译后的方法，即build目录下，因此如果你想要调试进行测试，需要在各个模块build目录下更改调试,如果更改源码，需要gulp transpile进行编译)

appium server

appium server端实现了HTTP REST API接口，将client端发来的API请求，解析，发送给执行端。apium server,以及其他的driver（android,ios）都实现了basedriver类。basedriver定义了session的创建，命令的执行方式(cmd执行)。

appium server(appium driver)大致的流程为：

• 解析命令行参数
• 注册路由方法
• 解析路由
  

我们看一下appium server的源码实现。

1. import { server as baseServer } from 'appium-base-driver';
   
2. import getAppiumRouter from './appium';
   
3. ...
   
4. 
   
5. async function main (args = null) {
   
6.   //解析参数
   
7.   let parser = getParser();
   
8.   let throwInsteadOfExit = false;
   
9.   if (args) {
   
10.     args = Object.assign({}, getDefaultArgs(), args);
    
11.     if (args.throwInsteadOfExit) {
    
12.       throwInsteadOfExit = true;
    
13.       delete args.throwInsteadOfExit;
    
14.     }
    
15.   } else {
    
16.     args = parser.parseArgs();
    
17.   }
    
18.   await logsinkInit(args);
    
19.   await preflightChecks(parser, args, throwInsteadOfExit);
    
20.   //输出欢迎信息
    
21.   await logStartupInfo(parser, args);
    
22.   //注册接口路由,参见(appium-base-driver\lib\jsonwp\Mjsonwp.js)
    
23.   let router = getAppiumRouter(args);
    
24.   //express server类(appium-base-driver\lib\express\server.js)
    
25.   //将注册的路由，传递给express注册.
    
26.   let server = await baseServer(router, args.port, args.address);
    
27.   try {
    
28.     //是否为appium grid的node节点
    
29.     if (args.nodeconfig !== null) {
    
30.       await registerNode(args.nodeconfig, args.address, args.port);
    
31.     }
    
32.   } catch (err) {
    
33.     await server.close();
    
34.     throw err;
    
35.   }
    
36. 
    
37.   process.once('SIGINT', async function () {
    
38.     logger.info(`Received SIGINT - shutting down`);
    
39.     await server.close();
    
40.   });
    
41. 
    
42.   process.once('SIGTERM', async function () {
    
43.     logger.info(`Received SIGTERM - shutting down`);
    
44.     await server.close();
    
45.   });
    
46. 
    
47.   logServerPort(args.address, args.port);
    
48. 
    
49.   return server;
    
50. }
    
51. ...
    
52. //路由
    
53. //appium.js,下面会讲解路由解析
    
54. function getAppiumRouter (args) {
    
55.   let appium = new AppiumDriver(args);
    
56.   return routeConfiguringFunction(appium);
    
57. }
    

复制代码

URL路由解析

上面说道，路由注册。所有支持的请求都METHOD_MAP这个全局变量里面。它是一个path:commd的对象集合。路由执行过程是：

• 检查命令类型(是否包含session)
• 设置代理
• 检查命令类型与参数
• 执行命令
  

我们来详细看一下(routeConfiguringFunction)到底做了什么(appium-base-driver\lib\mjsonwp\Mjsonwp.js):

1. 
   
2. function routeConfiguringFunction (driver) {
   
3.   if (!driver.sessionExists) {
   
4.     throw new Error('Drivers used with MJSONWP must implement `sessionExists`');
   
5.   }
   
6.   if (!(driver.executeCommand || driver.execute)) {
   
7.     throw new Error('Drivers used with MJSONWP must implement `executeCommand` or `execute`');
   
8.   }
   
9.   // return a function which will add all the routes to the driver
   
10.   return function (app) {
    
11.     //[METHOD_MAP](#route_config),是所有的路由配置,key为path,value为method的数组
    
12.    //对METHOD_MAP的配置进行绑定
    
13.     for (let [path, methods] of _.toPairs(METHOD_MAP)) {
    
14.       for (let [method, spec] of _.toPairs(methods)) {
    
15.         // set up the express route handler
    
16.         buildHandler(app, method, path, spec, driver, isSessionCommand(spec.command));
    
17.       }
    
18.     }
    
19.   };
    
20. }
    
21. //路由绑定
    
22. //示例：
    
23. /*
    
24.   '/wd/hub/session': {
    
25.     POST: {command: 'createSession', payloadParams: {required: ['desiredCapabilities'], optional: ['requiredCapabilities', 'capabilities']}}
    
26.   },
    
27. 即:
    
28. method: POST
    
29. path: /wd/hub/session
    
30. spec: array
    
31. driver: appium
    
32. */
    
33. function buildHandler (app, method, path, spec, driver, isSessCmd) {
    
34.   let asyncHandler = async (req, res) => {
    
35.     let jsonObj = req.body;
    
36.     let httpResBody = {};
    
37.     let httpStatus = 200;
    
38.     let newSessionId;
    
39.     try {
    
40.       //判断是否是创建session命令(包含createSession,getStatus,getSessions)
    
41.       //是否有session
    
42.       if (isSessCmd && !driver.sessionExists(req.params.sessionId)) {
    
43.         throw new errors.NoSuchDriverError();
    
44.       }
    
45.       //设置了代理则透传
    
46.       if (isSessCmd && driverShouldDoJwpProxy(driver, req, spec.command)) {
    
47.         await doJwpProxy(driver, req, res);
    
48.         return;
    
49.       }
    
50.       //命令是否支持
    
51.       if (!spec.command) {
    
52.         throw new errors.NotImplementedError();
    
53.       }
    
54.       //POST参数检查
    
55.       if (spec.payloadParams && spec.payloadParams.wrap) {
    
56.         jsonObj = wrapParams(spec.payloadParams, jsonObj);
    
57.       }
    
58.       if (spec.payloadParams && spec.payloadParams.unwrap) {
    
59.         jsonObj = unwrapParams(spec.payloadParams, jsonObj);
    
60.       }
    
61.       checkParams(spec.payloadParams, jsonObj);
    
62.       //构造参数
    
63.       let args = makeArgs(req.params, jsonObj, spec.payloadParams || []);
    
64.       let driverRes;
    
65.       if (validators[spec.command]) {
    
66.         validators[spec.command](...args);
    
67.       }
    
68.       //!!!!执行命令
    
69.       //捕获返回值
    
70.       if (driver.executeCommand) {
    
71.         driverRes = await driver.executeCommand(spec.command, ...args);
    
72.       } else {
    
73.         driverRes = await driver.execute(spec.command, ...args);
    
74.       }
    
75. 
    
76.       // unpack createSession response
    
77.       if (spec.command === 'createSession') {
    
78.         newSessionId = driverRes[0];
    
79.         driverRes = driverRes[1];
    
80.       }
    
81.       ...
    
82.     } catch (err) {
    
83.       [httpStatus, httpResBody] = getResponseForJsonwpError(actualErr);
    
84.     }
    
85.     if (_.isString(httpResBody)) {
    
86.       res.status(httpStatus).send(httpResBody);
    
87.     } else {
    
88.       if (newSessionId) {
    
89.         httpResBody.sessionId = newSessionId;
    
90.       } else {
    
91.         httpResBody.sessionId = req.params.sessionId || null;
    
92.       }
    
93. 
    
94.       res.status(httpStatus).json(httpResBody);
    
95.     }
    
96.   };
    
97.   // add the method to the app
    
98.   app[method.toLowerCase()](path, (req, res) => {
    
99.     B.resolve(asyncHandler(req, res)).done();
    
100.   });
     
101. }

复制代码

创建session 与 executeCommand

lib\appium.js

上面说了appium server已经启动了，第一件事情，当然是创建session,然后把command交给这个session的不同driver去执行了。

appium先根据caps进行session创建（getDriverForCaps）,然后保存InnerDriver到当前session,以后每次执行命令(executeDCommand)会判断是否为appiumdriver的命令，不是则转给相应的driver去执行命令(android,ios等)。

1. async createSession (caps, reqCaps) {
   
2.   caps = _.defaults(_.clone(caps), this.args.defaultCapabilities);
   
3.   let InnerDriver = this.getDriverForCaps(caps);
   
4.   this.printNewSessionAnnouncement(InnerDriver, caps);
   
5. 
   
6.   if (this.args.sessionOverride && !!this.sessions && _.keys(this.sessions).length > 0) {
   
7.     for (let id of _.keys(this.sessions)) {
   
8.       log.info(`    Deleting session '${id}'`);
   
9.       try {
   
10.         await this.deleteSession(id);
    
11.       } catch (ign) {
    
12.       }
    
13.     }
    
14.   }
    
15. 
    
16.   let curSessions;
    
17.   try {
    
18.     curSessions = this.curSessionDataForDriver(InnerDriver);
    
19.   } catch (e) {
    
20.     throw new errors.SessionNotCreatedError(e.message);
    
21.   }
    
22. 
    
23.   let d = new InnerDriver(this.args);
    
24.   let [innerSessionId, dCaps] = await d.createSession(caps, reqCaps, curSessions);
    
25.   this.sessions[innerSessionId] = d;
    
26.   this.attachUnexpectedShutdownHandler(d, innerSessionId);
    
27.   d.startNewCommandTimeout();
    
28. 
    
29.   return [innerSessionId, dCaps];
    
30. }
    
31.   async executeCommand (cmd, ...args) {
    
32.   if (isAppiumDriverCommand(cmd)) {
    
33.     return super.executeCommand(cmd, ...args);
    
34.   }
    
35. 
    
36.   let sessionId = args[args.length - 1];
    
37.   return this.sessions[sessionId].executeCommand(cmd, ...args);
    
38. }
    

复制代码

在basedriver中executeDCommand其实是调用类的cmd定义的方法。