sonic 用的就是 supervisord 来管理进程 go daemon 是否可以用 docker 和 docker-compose 来管理

所有编译器理论原理基本一致

实例

概念级理解

docker 和 kubernetes 的编排之争，前提是 docker 不安于现状，不想仅仅做提供应用程序打包发布的 “幕后英雄”，而是想要进军完整的 “PaaS”，而完整的 "PaaS" 不仅仅需要应用程序，还需要提供一种 编排，集群管理，负载均衡 的能力，所以，docker compose 和 swarm 的出现也是必然，为了应对 docker Paas 化的冲击，kubernetes 应运而生

Rook将分布式存储系统转变为自我管理，自我扩展，自我修复的存储服务。<br> 它可以自动执行存储管理员的任务：

• 部署，
• 引导，
• 配置，
• 配置，
• 扩展，
• 升级，
• 迁移，
• 灾难恢复，
• 监控
• 资源管理。

Replication Controller -- RC<br> 确保用户定义的Pod副本数保持不变，也就是说<br> 如果pod增多，则ReplicationController会终止额外的pod，如果减少，RC会创建新的pod

当在SRIOV中设置并且e-switch配置为switchdev模式时，表示符由主机PCI驱动程序创建。 目前，在mlx5中，e-switch管理是通过PF e-switch vport完成的，因此VF表示器与现有PF网络设备一起完成，后者表示上行链路共享PCI PF设备实例

传统的虚拟机管理程序将仿真或半虚拟（PV）设备暴露给guest 虚拟机，并通过驻留在主机操作系统中的软件交换机将guest 的I / O请求多路复用到真实硬件上

这样OVS代码就不会“改变”...... 我们插入了新的dpif硬件加速模块，它暴露了dpif提供者应该公开的相同API并使用标准的dpif netlink。

Open-vSwitch nic HW acceleration ==> ASAP

我们已经实现并升级了一种设计，允许享受SRIOV的性能优势，同时保持基于流的方法，以便在Open-vSwitch中使用访客流量。

为了支持OVS中的HW策略并使用TC 需要有一个新的dpif提供程序，我们将其命名为dpif-HW-acc，根据策略使用TC或dpif netlink

1. 从registry获取manifest(image 配置文件)
2. 读取manifest配置文件的digest，这个就是image id
3. 根据image id查看本地有无相同id的image
4. 如果没有，会给registry服务发送请求，获取image的配置文件
5. 查看本地每一个layer是否存在
6. 如果不存在，则会去服务器拿相应的layer
7. 等所有的layer下载完成后，image就下载完成了

如果这是生产情况，安全性和稳定性很重要，那么“便利”可能不是最好的决定因素（不仅仅是让你的房子一直解锁可能是“方便的”）

• 您可以考虑将每个push to registry的版本 - 以某种形式（毕竟，您发布了新版本的代码，并使其他人可以访问）。
• :latest与Git存储库中的master分支相当。是否每个push to master都考虑准备投入生产？
• Releases将（通常）通过验证过程（CI/QA /acceptance/etc）。是否应首先验证master中的更改，并且仅在验证（标记并）部署到生产之后？
• 发行版(Releases)带有版本;这可以是显式版本（标记），也可以是隐式（不可变标记：图像的摘要）

显式版本 -- image tag<br> 隐式版本 -- 不可变标记 ：image digest

现在这是一个问题，因为同一服务的不同实例现在运行不同版本的应用程序;这可能导致难以发现的问题，例如：

• 根据访问者最终的节点（或实例），可能会向他们提供不同的内容
• 对服务进行了安全更新，但某些实例仍然运行旧版本
• 修复了一个错误，但由于“某些原因”，一些节点仍然暴露了该错误
• 最新的更新包含一个错误，但它没有引起注意，因为大多数实例仍在运行以前的版本

docker stack deploy中不推荐使用--resolve-image=never<br> 这样做会恢复到原来的行为，即只在每个节点上拉动图像。这曾经引起相当多的问题，并且当时是作为权宜之计的解决方案（直到通过摘要实现固定）。本节说明了此方法的一些问题。

但是，摘要与标签之间没有1：1的关系，因此在通过摘要pull image时，只知道摘要。如果您碰巧使用与该摘要匹配的标记（手动）拉出图像，则会显示标记，否则不会显示

服务间通讯被完全剥离出来了，通过一个抽象层进行转发，这个抽象层就是服务间通讯专用基础设施层，也就是service mesh

多服务调用情况下

所有的服务通过“服务间通讯专用基础设施层”来和客户端交互<br> 服务不再负责传递请求的具体逻辑<br> 服务只需要完成业务处理<br> 服务间通讯环节从应用里剥离出来

service mesh 是一个基础设施层

• 功能：处理服务间通信
• 职责：实现请求的可靠传递
• 实现：通常实现为轻量级网络代理 -- proxy
• 位置：与app部署在一起，对应用程序透明

检查是否收到dhcp request<br> grep DHCP /var/log/syslog

RackHD可以自动发现尝试在RackHD正在监控的网络上进行PXE引导的节点

几个关键点：

1. rackhd-server是自动发现节点的
2. 该节点属于RackHD监控的网络上
3. 该节点尝试通过PXE引导节点

NodeId是RackHD中节点的唯一标识。通过键入以下命令，列出在rackhd-server SSH控制台上发现的所有计算类型节点。将“？type = compute”附加为查询字符串。

Docker Compose设置还启用端口转发，允许您的localhost访问RackHD实例

• rackhd_admin网络将用于将服务连接在一起并访问RackHD API
• RackHD将使用rackhd_southbound网络连接到虚拟节点

• maven-archetype-archetype
• maven-archetype-j2ee-simple
• maven-archetype-mojo
• maven-archetype-portlet
• maven-archetype-profiles (currently under development)
• maven-archetype-quickstart
• maven-archetype-simple (currently under development)
• maven-archetype-site
• maven-archetype-site-simple
• maven-archetype-webapp

### 构建java项目
# mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=myapp -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

### 构建javaweb项目
# mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-WebApp -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false

运行jjava程序，是通过java命令加上jar包来完成

# java -cp xxxxx.jar xxxxx

1. pom意思就是project object model
2. pom.xml包含了项目构建的信息，包括项目的信息，项目的依赖等
3. pom.xml文件是可以继承的，大型项目中，子模块的pom.xml一般都会继承于父模块的pom.xml

由于Maven命令实际上是执行了Java命令，所以可以通过JAVA命令参数的方式来设置MAVEN运行参数。MAVEN_OPTS环境变量正是用于此用途

MAVEN_OPTS -Xms128m -Xmx512m，分别设置JVM的最小和最大内存

默认情况下，通道在发送和接收值时会阻塞，因此它们将被等待。

最后，我们在末尾添加`xml：“sitemap”`语法，以便解析器在我们使用encoding / xml包解压缩它时的位置。

type Sitemapindex struct {
    Locations []Location `xml:"sitemap"`
}

就个人而言，我会测试两者。

如果在可能的情况下使用值接收器并且您正在使用指针接收器，则增益无关紧要，请确保使用所有指针接收器。

如果使用值接收器获取的收益微不足道，那么在可能的情况下，使用指针接收器，当然，所有地方都使用指针接收器

但是，如果使用值接收器可以获得可观的收益，那么在可能的情况下，会亲自使用它们

现在，我们通过指针修改结构本身。现在在代码中我们可以做类似a_car.new_top_speed（500）的事情，这实际上会修改对象本身

在func关键字和方法名之间，我们传递了变量和类型，

我们使用c，汽车的简称，然后汽车，这是与汽车结构相关联。这样就把struct和method关联了起来

在这种情况下，该方法获取对象的副本，因此您无法在此实际修改它，您只能执行操作或执行类似计算的操作 通过把struct和method关联了起来，使得方法获取到了对象的副本

func (c car) kmh() float64 {
    return float64(c.gas_pedal) * (c.top_speed_kmh/usixteenbitmax)
}

我们想把gas_pedal的值转化成某种实际的速度，为了做到这一点，我们不需要实际修改a_car变量，所以我们可以在值上使用一个方法，称为值 接收器

func (c car) kmh() float64 {
    return float64(c.gas_pedal) * (c.top_speed_kmh/usixteenbitmax)
}

只访问值的方法称为值接收器，只有获取值的需求时，用值接收器

可以修改信息的方法是指针接收器，需要修改struct信息时，用指针接收器

// 声明变量，默认 map 是 nil
var map_variable map[key_data_type]value_data_type

// 使用make 函数
map_variable := make(map[key_data_type]value_data_type)

numbers := []int{0,1,2,3,4,5,6,7,8}

len=2 cap=9 slice=[0 1]

len=3 cap=7 slice=[2 3 4]

s := make([]int, len, cap)

s := arr[:]

func setArray(params []int) {
    fmt.Println("params array length of setArray is : ", len(params))
}

func setArray2(params [5]int) {
    fmt.Println("params array length of setArray2 is : ", len(params))
}

a = [3][4]int {
    {0, 1, 2, 3} ,
    {4, 5, 6, 7} ,
    {8, 9, 10, 11} ,    // 此处的逗号是必须要有的
}

上面代码也可以等价于

a = [3][4]int {
    {0, 1, 2, 3} ,
    {4, 5, 6, 7} ,
    {8, 9, 10, 11}}

闭包，A函数 返回一个函数，假设返回的函数为B，那么函数B，可以使用A函数中的变量

nextNumber := getSequence()

nextNumber 是 返回函数B类型，func() int，i是函数A中的变量，初始值 i=0

执行nextNumber()，i+=1, reuturn i ==> 1

再执行nextNumber()，i+=1，return i ==> 2

再执行nextNumber()，i+=1，return i ==> 3

for key, value := range oldMap {
     newMap[key] = value
}

• 每个case都必须是一个通信
• 所有channel表达式都会被求值
• 所有被发送的表达式都会被求值
• 如果任意某个通信可以进行，它就执行；其他被忽略。
• 如果有多个case都可以运行，Select会随机公平地选出一个执行。其他不会执行。

否则：

1. 如果有default子句，则执行该语句。
2. 如果没有default字句，**select将阻塞，直到某个通信可以运行**；Go不会重新对channel或值进行求值。

package main
import "fmt"
const (
    i=1<<iota
    j=3<<iota
    k
    l
)
func main() {
    fmt.Println("i=", i)
    fmt.Println("j=", j)
    fmt.Println("k=", k)
    fmt.Println("l=", l)
}

以上实例运行结果为：

i=1
j=6
k=12
l=24

var (
    vname1 v_type1
    vname2 v_type2
)

• Path : /Service-Name/{method name}
• Service-Name: ?( {proto package name} "." ) {service name}
• Message-Type: {fully qualified proto message name}
• Content-Type: "application/grpc+proto"

使用 protobuf 协议定义好 service RPC

基于 HTTP/2 进行通信

voltha里面有部分代码使用了Twisted架构

CORD平台将数据中心的经济性和云的灵活性带到了TELCO网络的边缘。

CORD基础架构基于商用服务器和白盒交换机，利用SDN互连虚拟和物理元素，并实现创新服务

R-CORD

R-CORD是一种基于CORD平台的开源解决方案，

用于提供超宽带住宅服务。

R-CORD将运营商网络的优势转变为灵活的服务交付平台， 使运营商能够提供最佳的最终用户体验以及创新的下一代服务。 可以使用各种接入技术，包括：GPON，G.Fast，10GPON和DOCSIS。

R-CORD

通过有线接入技术支持住宅用户，如GPON，G.Fast，10GPON和DOCSIS

CORD提供了一个完整的集成平台，

集成了创建具有内置服务功能的完整运营边缘数据中心所需的一切，

所有这些都使用最新的云原生设计原则构建在商用硬件上。

CORD（中央办公室重新构建为数据中心）平台

利用SDN，NFV和云技术为网络边缘构建灵活的数据中心。

CORD集成了多个开源项目，为网络运营商提供了一个云原生(cloud-native)，开放(open)，可编程(programmable)，灵活的平台(agile platform)，以创建创新服务。

CORD central office re-architected as d datacenter

运营商边缘网络（例如电信公司的中心局和有线电视运营商的前端）是运营商连接到客户的地方。

CORD™旨在将这一优势转变为(agile service delivery platform)灵活的服务交付平台，使运营商能够提供最佳的最终用户体验以及创新的下一代服务 的一个工程

自己部署的时候确实会出现新建空白metadata.db出错的问题，不能成功新建DB，所以要利用桌面版新建一个空白db,拷贝到目录下

import eventlet
def func(*args, **kwargs):
    ... ...
    return 0

gt = eventlet.spawn(func, *args, **kwargs)
gt.wait()

当要切换到的目标对象还未激活（从未运行过）时，在切换过程中会执行初始化动作并运行。

主进程执行到gt.wait()时，会切换协程，真正开始执行代码

RoutesMiddleware 主要作用：

1. 将HTTP的URL请求映射到相应WSGI函数
2. 讲路由匹配结果存到environ环境变量中

@wsgi.response(202)
@wsgi.serializers(xml=FullServerTemlate)
@wsgi.deserializers(xml=CreateDeserializer)
def create(self, req, body):

1. 第一次请求(http://82.0.0.5/v3/tokens)发送给keystone获取授权token，并填充到X-Auth-Token字段中

2. 基于第一次请求获取token，发送第二次请求(http://82.0.0.5/v2.1/servers/detail)给 Nova service 获取虚拟机列表

官网

curl -i -X PUT -H "X-Auth-Token: $token" -H "Content-Type: application/octet-stream" -d @/home/glance/ubuntu-12.10.qcow2 $image_url/v2/images/{image_id}/file

方法二

curl -i -X PUT -H "X-Auth-Token: $token" -H "Content-Type: application/octet-stream" --upload-file @/home/glance/ubuntu-12.10.qcow2 $image_url/v2/images/{image_id}/file

curl -H "Content-Type:application/json" -X POST -d '{"user": "admin", "passwd":"12345678"}' http://127.0.0.1:8000/login

*cmd：这是服务的启动脚本，即所有服务的main函数。看服务怎么初始化，就从这里开始。

• db: 封装数据库访问，目前支持的driver为sqlalchemy。
• conf：Nova的配置项声明都在这里。
• locale: 本地化处理。
• image: 封装Glance调用接口。
• network: 封装网络服务接口，根据配置不同，可能调用nova-network或者neutron。
• volume: 封装数据卷访问接口，通常是Cinder的client封装。
• virt: 这是所有支持的hypervisor驱动，主流的如libvirt、xen等。
• objects: 对象模型，封装了所有实体对象的CURD操作，相对以前直接调用db的model更安全，并且支持版本控制。
• policies： policy校验实现。
• tests: 单元测试和功能测试代码。

• api.py：供其它组件调用的接口
• rpcapi.py：RPC Client库，用于封装RPC调用
• manager.py：所有RPC服务端代码入口，也是核心功能的实现部分
• servers.py：云主机生命周期管理

from module_11包名.module_11 import funcA

• API是进入Nova的HTTP接口
• Compute和虚拟机管理器交互来运行虚拟机（经常是一个主机一个Compute服务)
• Network通过和交换机、路由器、防火墙以及相关设备来管理Ip地址池
• Scheduler从可用池中选择最合适的计算节点来创建新的实例（它也可能用来选择Volumes）

>>> "django.core.app".partition('.')
('django', '.', 'core.app')
>>> "django.core.app".rpartition('.')
('django.core', '.', 'app')

有时脚本可能只解析一些命令行参数，将剩下的参数传递给另一个脚本或程序。 在这种情况下，parse_known_args() 方法可能很有用。 它的工作方式与parse_args() 非常相似，只是在出现额外参数时不会产生错误。 相反，它会重新生成包含已填充名称空间和剩余参数字符串列表的两个项目元组。

import argparse  
parser = argparse.ArgumentParser()  
parser.add_argument(  
    '--flag_int',  
    type=float,  
    default=0.01,  
    help='flag_int.'  
)  
FLAGS, unparsed = parser.parse_known_args()  
print(FLAGS)  
print(unparsed)

# python test.py --flag_int 1 --flag_bool True --flag_string 'haha, I get it' --flag_float 0.2

Namespace(flag_int=1.0)
['--flag_bool', 'True', '--flag_string', 'haha, I get it', '--flag_float', '0.2']

• 协程锁: semaphore.Semaphore() 实现
• 进程锁: Nova 在 semaphore.Semaphore() 基础之上自身实现的跨进程的文件锁

AMQP 引入了消息中间件

从RPC角度来看，Client端要远程调用Server端的函数

从AMQP角度来看，Client要发起请求，产生请求消息，所以是Producer，Server端需要获取消息消费，才能进行相应的处理，所以是Consumer

common_opts = [
    cfg.Opt( 'bind_port',
              type=PortType,
              default=9292,
              help='Port number to listen')
]
### 等价于
common_opts = [
    cfg.PortOpt( 'bind_port',
                  default=9292,
                  help='Port number to listen')
]

Hook式加载

不需要知道插件的具体名字，指定namespace='xxxx'，则会加载xxxx entry point group下的所有插件(扩展)

要调用插件 ==> manager.map(func, args) ==> namespace中的每个插件都会调用该函数func ==> manager.map(func, args) return 一个序列，序列中的每个元素就是每个插件调用回调函数的返回值

注册插件是通过 setup.py 来注册插件的

from setuptools import setup, find_packages
setup(
    name='test',
    version='1.0',
    packages=find_packages(),
    entry_points={
        'namespace': [
            'name = module:importable'
        ],
    },
)

1. Drivers：一个名字对应一个entry point

2. Hooks：一个名字对应多个entry point

3. Extensions：多个名字对应多个entry point

ceilometer.compute.virt =   
    libvirt = ceilometer.compute.virt.libvirt.inspector:LibvirtInspector  
    hyperv = ceilometer.compute.virt.hyperv.inspector:HyperVInspector  
    vsphere = ceilometer.compute.virt.vmware.inspector:VsphereInspector  

ceilometer.hardware.inspectors =  
    snmp = ceilometer.hardware.inspectors.snmp:SNMPInspector

• ceilometer.compute.virt 和 ceilometer.hardware.inspectors是两个命名空间
• ceilometer.compute.virt 有 libvirt，hyperv，vsphere 三个插件，ceilometer.hardware.inspectors 有 snmp 一个插件
• 插件的具体可载入实现是每个插件等号后面的具体类

注意：由于路由与URL的列表相匹配，它不具有作为资源的路由的固有知识，因此，如果由于未满足方法要求而导致路由不匹配，则404将像任何其他路由失败一样返回以匹配路由。

静态路由仅用于URL生成，不会用于匹配，并且必须命名。使用参数 _static=True 来定义静态路由

但是，如果路由定义了一个额外变量和 url() 的路径变量名称相同，如果未指定该关键字，那么额外变量将用 作默认值

### id 作为额外参数
m.connect("archives", "/archives/{id}",
    controller="archives", action="view", id=1)
### id作为路径参数
url("archives", id=123)  =>  "/archives/123"
url("archives")  =>  "/archives/1"

如果路由包含path variables(路径变量)，则必须使用关键字参数设置这些变量值：

要生成一个带名字的路由，指定路由名作为位置参数

如果在URL的末尾使用“path_info”变量，则Routes会将其前面的所有内容移动到“SCRIPT_NAME”环境变量中。

当委派另一个WSGI应用程序执行自己的路由时，这非常有用：子应用程序将路由剩余的URL而不是整个URL。

您仍需要“:.*” requirement 才能将以下URL组件捕获到变量中。

map.connect(None, "/cards/{path_info:.*}",
    controller="main", action="cards")
# Incoming URL "/cards/diamonds/4.png"
=> {"controller": "main", action: "cards", "path_info": "/diamonds/4.png"}
# Second WSGI application sees:
# SCRIPT_NAME="/cards"   
# PATH_INFO="/diamonds/4.png"

Mapper在Web应用程序中处理URL生成和URL识别。

Mapper是建立处理字典的。 假定Web应用程序将处理返回由URL识别并正确分派的字典。

通过将关键字参数传递到生成函数来完成URL生成，然后返回一个URL。

class Mapper(SubMapperParent):

    def __init__(self, 
            controller_scan=controller_scan, 
            directory=None,
            always_scan=False, 
            register=True, 
            explicit=True):
### Create and connect a new 
### Route to the Mapper
    def connect(self, 
                routename, 
                path=None, 
                **kwargs):
        ........

With that myfunc will be a WSGI application, callable like

app_iter = myfunc(environ, start_response).

You can also call it like normal

resp = myfunc(req)

You can also wrap methods

def myfunc(self, req).)

不添加装饰器，打印type(myfunc)

<type 'function'>

添加装饰器之后，打印type(myfunc)

<class 'webob.dec.wsgify'>

### environ 是 WSGI环境变量
req = Request(environ)
把 environ 字典 转换成 <class 'webob.request.Request'> Request对象
所以 webob.Request是对WSGI环境变量的一个封装

class AnimalApplication(object):
    @classmethod
    def factory(cls, global_conf, **kwargs):
        print cls
        return cls()

<class '__main__.AnimalApplication'>
==> cls 指的是类本身

WSGI框架下一些常用的 python module

• eventlet
• paste.deploy
• routes

比如，可在 middleware 中实现以下功能：

• 根据 url 把用户请求调度到不同的 application 中。
• 负载均衡，转发用户请求
• 预处理 XSL 等相关数据
• 限制请求速率，设置白名单

middleware 介于 sever/gateway 和 application/framework 之间 该怎么理解

• 简单考虑，没有middleware时，创建server时指定application，请求发生时，调用application
• 那么有middleware是什么情况呢？middleware接收application作为入参，这样就把middleware和application这一端连接起来，对于application来说，middleware就像server一样，middleware把application执行结果返回给server，对于server来说，middleware就像application一样

• 接受两个参数：字典dict (environ)，回调函数(start_response，返回 HTTP status, headers 给 web server)
• 返回一个可以迭代的值

WSGI -- web server gateway interface

是一种 web server/gateway 和 python web application/framework 之间的通用接口

符合这种接口的application，都可以运行在符合该接口的server上

application <==> web server gateway interface <==> server

WSGI -- a interface of python web applications or frameworks

由此可见，系统调用 --- system call 的一些特性：

user-space 只能调用 system call（就像调用普通函数一样） user-space 不能执行 system call，system call 的执行在 kernel-space。 kernel-space 负责执行函数，函数的 body 部分就是与 IO 进行交互，read/write 等。 整个过程，user-space thread 不会 sleep，也就是不释放 CPU，且程序不再前进，所以是 blocking and sync 到底什么是 sync 和 async 注意：

sync 的意思是 不释放CPU async 的意思是 释放CPU 如何理解呢：

释放 CPU 的话，在 CPU 眼里就没有这个线程了，不会给其分配 time slicing, like this:

.    |    |    |    |
.    |    |    |    |
.    |    |    |    |

第一个线程是 async 的，那么他在 CPU 眼里是不存在的， CPU 也不会再给他分配 time slicing.

|    |    |    |    |
|    |    |    |    |
|    |    |    |    |

第一个线程是 sync 的，那么他在 CPU 眼里依旧存在， CPU 照常给他分配 time slicing.

这就是 async 和 sync 的区别，他是关于 CPU是否给其分配 time slicing 的词汇 这就是 async 和 sync 的区别，他是关于 CPU是否给其分配 time slicing 的词汇

user-space vs. kernel space 系统函数只能在 kernel-space 中执行；但可以在 user-space 中调用。 系统函数在 kernel-space 中执行完毕后需要把结果拷贝给 user-space 中发起调用的线程，作为函数的返回结果。 所以系统调用这个东西吧，像是隔了一层，和普通的 API 函数还不一样。> When the read system call is invoked, the application blocks and the context switches to the kernel. The read is then initiated, and when the response returns (from the device from which you're reading), the data is moved to the user-space buffer.

由此可见，系统调用 --- system call 的一些特性：

1. user-space 只能调用 system call（就像调用普通函数一样）
2. user-space 不能执行 system call，system call 的执行在 kernel-space。
3. kernel-space 负责执行函数，函数的 body 部分就是与 IO 进行交互，read/write 等。
4. 整个过程，user-space thread 不会 sleep，也就是不释放 CPU，且程序不再前进，所以是 blocking and sync

到底什么是 sync 和 async

注意：

• sync 的意思是 不释放CPU
• async 的意思是 释放CPU

如何理解呢：

释放 CPU 的话，在 CPU 眼里就没有这个线程了，不会给其分配 time slicing, like this:

.    |    |    |    |
.    |    |    |    |
.    |    |    |    |

第一个线程是 async 的，那么他在 CPU 眼里是不存在的， CPU 也不会再给他分配 time slicing.

|    |    |    |    |
|    |    |    |    |
|    |    |    |    |

第一个线程是 sync 的，那么他在 CPU 眼里依旧存在， CPU 照常给他分配 time slicing.

这就是 async 和 sync 的区别，他是关于 CPU是否给其分配 time slicing 的词汇

这就是 async 和 sync 的区别，他是关于 CPU是否给其分配 time slicing 的词汇

user-space vs. kernel space

• 系统函数只能在 kernel-space 中执行；但可以在 user-space 中调用。
• 系统函数在 kernel-space 中执行完毕后需要把结果拷贝给 user-space 中发起调用的线程，作为函数的返回结果。
• 所以系统调用这个东西吧，像是隔了一层，和普通的 API 函数还不一样。

IO复用模型，Linux下的select, poll, epoll就是干这个的

• select将用户socket对应fd注册进epoll
• 然后epoll监听哪些socket上有消息到达，此时socket应采用非阻塞模式

操作系统的这个通知机制，是I/O多路复用技术的基础

The protocol specifies methods to be implemented to make our objects iterable.

该协议指定了要实现我们的对象迭代的方法。

"Iterable" simply means able to be looped over or otherwise treated as a sequence or collection.

“可迭代”仅仅意味着能够循环或像对待序列或集合一样的方式处理。

Introduction of Classes 类允许我们创建一个自定义类型的对象 - 也就是说，一个对象具有自己的行为和自己的存储数据的方式。

从package多文件访问变量的注意事项

Introduction python packages

packages是一个文件目录，可以作为Python应用程序或库模块一起工作

递归调用三要素：

1. recursive call: 递归调用，这是函数对自己的调用;
2. function process: 函数过程本身;
3. base condition: 一个基本条件，这是递归链最终返回的点。

*args 和 **kwargs 可以代表所有参数

为了允许装饰函数接受参数，我们必须接受它们并将它们传递给装饰函数。

什么是object -- 是一个具有类型的数据 什么是变量 -- 是一个绑定对象的名字

pytest Basics

• 单元测试 -- 测试单个单元，方法
• 集成测试 -- 集中测试多个单元
• 回归测试 -- 测试修改有没有引入新的错误
• 端到端测试 -- 测试整个程序

At the start of your session,these will format your sqlite3 output so it is clearer, and add columns headers.

Introduction to Pandas

Pandas is used to manipulation and analysis of tabular data

pandas reference and tutorials include：full docs, 10minutes to pandas, blog tutorials

当整个群集关闭时， 最后一个要关闭的节点必须是第一个要联机的节点。 如果没有发生这种情况，则节点将等待30秒钟，以使最后一个光盘节点重新联机，然后再失败

运行RabbitMQ代理所需的所有数据/状态都将在所有节点上进行复制。

一个例外是消息队列，默认情况下驻留在一个节点上，尽管它们可以从所有节点看到并且可以访问

rabbitmq是AMQP的一种基于Erlang的实现

rabbitmq_amqqueue_process队列进程和rabbit_msg_store消息持久化进程，都是RabbitMQ启动或者创建队列时创建的

Erlanng是一门动态类型的函数式编程语言，也是一门解释型语言，由Erlang虚拟机解释执行

Tempest 测试的4种结果

• Error -- 错误 -- Tempest测试代码执行时报错
• Failure -- 失败 -- 测试代码执行正常，但是没有得到预期测试结果
• Skip -- 跳过 -- 测试忽略
• Success -- 成功 -- 测试用例执行成功。测试程序返回预期结果

ostestr 部分命令 ostestr openstack文档部分介绍

• running Tests
• Test Selection
• Output Options

nosetests 会根据是否带有‘tests’一词作为其名称的一部分，来作为识别什么是测试，什么不是测试

实际情况是，有些带有tests的函数并不是测试，所以nostests和testrs测试的数量不一样

社区推荐使用ostestr

tempest scenario tests，tempest场景测试用例，相关简要概述，以及需要用到的openstack services

run tempest

### 使用testr测试工具
# testr run --parallel xxxx

### 使用nosetests测试工具
# nosetests -vx xxxxx

• tempest init workdir 初始化目录
• tempest run --list-tests 列出可执行的测试列表
• tempest run --serial --regex xxx
• testr run xxx
• nosetests -vx xxx