mirror of
https://github.com/LCTT/TranslateProject.git
synced 2025-01-01 21:50:13 +08:00
Merge branch 'master' of https://github.com/LCTT/TranslateProject
This commit is contained in:
geekpi
commit
9b467e110f
95
published/20160511 LEDE and OpenWrt.md
Normal file
95
published/20160511 LEDE and OpenWrt.md
Normal file
@ -0,0 +1,95 @@
|
||||
LEDE 和 OpenWrt 分裂之争
|
||||
===================
|
||||
|
||||
对于家用 WiFi 路由器和接入点来说，[OpenWrt][1] 项目可能是最广为人知的 Linux 发行版；在 12 年以前，它产自现在有名的 Linksys WRT54G 路由器的源代码。（2016 年）五月初，当一群 OpenWrt 核心开发者 [宣布][2] 他们将开始着手 OpenWrt 的一个副产品 （或者，可能算一个分支）叫 [Linux 嵌入开发环境][3] （LEDE）时，OpenWrt 用户社区陷入一片巨大的混乱中。为什么产生分裂对公众来说并不明朗，而且 LEDE 宣言惊到了一些其他 OpenWrt 开发者也暗示这团队的内部矛盾。
|
||||
|
||||
LEDE 宣言被 Jo-Philipp Wich 于五月三日发往所有 OpenWrt 开发者列表和新 LEDE 开发者列表。它将 LEDE 描述为“OpenWrt 社区的一次重启” 和 “OpenWrt 项目的一个副产品” ，希望产生一个 “注重透明性、合作和权利分散”的 Linux 嵌入式开发社区。
|
||||
|
||||
给出的重启的原因是 OpenWrt 遭受着长期以来存在且不能从内部解决的问题 —— 换句话说，关于内部处理方式和政策。例如，宣言称，开发者的数目在不断减少，却没有接纳新开发者的方式（而且貌似没有授权委托访问给新开发者的方法）。宣言说到，项目的基础设施不可靠（例如，去年服务器挂掉在这个项目中也引发了相当多的矛盾），但是内部不合和单点错误阻止了修复它。内部和从这个项目到外面世界也存在着“交流、透明度和合作”的普遍缺失。最后，一些技术缺陷被引述：不充分的测试、缺乏常规维护，以及窘迫的稳固性与文档。
|
||||
|
||||
该宣言继续描述 LEDE 重启将怎样解决这些问题。所有交流频道都会打开供公众使用，决策将在项目范围内的投票决出，合并政策将放宽等等。更详细的说明可以在 LEDE 站点的[规则][4]页找到。其他细节中，它说贡献者将只有一个阶级（也就是，没有“核心开发者”这样拥有额外权利的群体），简单的少数服从多数投票作出决定，并且任何被这个项目管理的基础设施必须有三个以上管理员账户。在 LEDE 邮件列表， Hauke Mehrtens [补充][5]到，该项目将会努力把补丁投递到上游项目 —— 这是过去 OpenWrt 被批判的一点，尤其是对 Linux 内核。
|
||||
|
||||
除了 Wich，这个宣言被 OpenWrt 贡献者 John Crispin、 Daniel Golle、 Felix Fietkau、 Mehrtens、 Matthias Schiffer 和 Steven Barth 共同签署，并以给其他有兴趣参与的人访问 LEDE 站点的邀请作为了宣言结尾。
|
||||
|
||||
### 回应和问题
|
||||
|
||||
有人可能会猜想 LEDE 组织者预期他们的宣言会有或积极或消极的反响。毕竟，细读宣言中批判 OpenWrt 项目暗示了 LEDE 阵营发现有一些 OpenWrt 项目成员难以共事（例如，“单点错误” 或 “内部不和”阻止了基础设施的修复）。
|
||||
|
||||
并且，确实，有很多消极回应。OpenWrt 创立者之一 Mike Baker [回应][6] 了一些警告，反驳所有 LEDE 宣言中的结论并称“像‘重启’这样的词语都是含糊不清的，且具有误导性的，而且 LEDE 项目未能揭晓其真实本质。”与此同时，有人关闭了那些在 LEDE 宣言上署名的开发者的 @openwrt.org 邮件入口；当 Fietkau [提出反对][7]， Baker [回复][8]账户“暂时停用”是因为“还不确定 LEDE 能不能代表 OpenWrt。” 另一个 OpenWrt 核心成员 Imre Kaloz [写][9]到，他们现在所抱怨的 OpenWrt 的“大多数[破]事就是 LEDE 团队弄出来的”。
|
||||
|
||||
但是大多数 OpenWrt 列表的回应对该宣言表示困惑。邮件列表成员不明确 LEDE 团队是否将对 OpenWrt [继续贡献][10]，或导致了这次分裂的架构和内部问题的[确切本质][11]是什么。 Baker 的第一反应是对宣言中引述的那些问题缺乏公开讨论表示难过：“我们意识到当前的 OpenWrt 项目遭受着许多的问题，”但“我们希望有机会去讨论并尝试着解决”它们。 Baker 作出结论：
|
||||
|
||||
> 我们想强调，我们确实希望能够公开的讨论，并解决掉手头事情。我们的目标是与所有能够且希望对 OpenWrt 作出贡献的参与者共事，包括 LEDE 团队。
|
||||
|
||||
除了有关新项目的初心的问题之外，一些邮件列表订阅者提出了 LEDE 是否与 OpenWrt 有相同的使用场景定位，给新项目取一个听起来更一般的名字的疑惑。此外，许多人，像 Roman Yeryomin，对为什么这些问题需要 LEDE 团队的离开（来解决）[表示了疑惑][12]，特别是，与此同时，LEDE 团队由大部分活跃核心 OpenWrt 开发者构成。一些列表订阅者，像 Michael Richardson，甚至不清楚[谁还会继续开发][13] OpenWrt。
|
||||
|
||||
### 澄清
|
||||
|
||||
LEDE 团队尝试着深入阐释他们的境况。在 Fietkau 给 Baker 的回复中，他说在 OpenWrt 内部关于有目的地改变的讨论会很快变得“有毒，”因此导致没有进展。而且：
|
||||
|
||||
> 这些讨论的要点在于那些掌握着基础设施关键部分的人精力有限却拒绝他人的加入和帮助，甚至是面对无法及时解决的重要问题时也是这样。
|
||||
|
||||
> 这种像单点错误一样的事已经持续了很多年了，没有任何有意义的进展来解决它。
|
||||
|
||||
Wich 和 Fietkau 都没有明显指出具体的人，虽然在列表的其他人可能会想到这个基础设施和 OpenWrt 的内部决策问题要归咎于某些人。 Daniel Dickinson [陈述][14]到：
|
||||
|
||||
> 我的印象是 Kaloz (至少) 以基础设施为胁来保持控制，并且根本性的问题是 OpenWrt 是*不*民主的，而且忽视那些真正在 OpenWrt 工作的人想要的是什么，无视他们的愿望，因为他/他们把控着要害。
|
||||
|
||||
另一方面， Luka Perkov [指出][15] 很多 OpemWrt 开发者想从 Subversion 转移到 Git，但 Fietkau 却阻止这种变化。
|
||||
|
||||
看起来是 OpenWrt 的管理结构并非如预期般发挥作用，其结果导致个人冲突爆发，而且由于没有完好定义的流程，某些人能够简单的忽视或阻止提议的变化。明显，这不是一个能长期持续的模式。
|
||||
|
||||
五月六日，Crispin 在一个新的帖子中[写给][16] OpenWrt 列表，尝试着重构 LEDE 项目宣言。他说，这并不是意味着“敌对或分裂”行为，只是与结构失衡的 OpenWrt 做个清晰的划分并以新的方式开始。问题在于“不要归咎于一次单独的事件、一个人或者一次口水战”，他说，“我们想与过去自己造成的错误和多次作出的错误管理决定分开”。 Crispin 也承认宣言没有把握好，说 LEDE 团队 “弄糟了发起纲领。”
|
||||
|
||||
Crispin 的邮件似乎没能使 Kaloz 满意，她[坚持认为][17] Crispin（作为发行经理）和 Fietkau（作为领头开发者）可以轻易地在 OpenWrt 内部作出想要的改变。但是讨论的下文后来变得沉寂；之后 LEDE 或者 OpenWrt 哪边会发生什么还有待观察。
|
||||
|
||||
### 目的
|
||||
|
||||
对于那些想要探究 LEDE 所认为有问题的事情的更多细节的 OpenWrt 成员来说，有更多的信息来源可以为这个问题提供线索。在公众宣言之前，LEDE 组织花了几周谈论他们的计划，会议的 IRC 日志现已[发布][18]。特别有趣的是，三月三十日的[会议][19]包含了这个项目目标的细节讨论。
|
||||
|
||||
其中包括一些针对 OpenWrt 的基础设施的抱怨，像项目的 Trac 工单追踪器的缺点。它充斥着不完整的漏洞报告和“我也是”的评论，Wich 说，结果几乎没有贡献者使用它。此外，他们也在 Github 上追踪 bug，人们对这件事感到困惑，这使得工单应该在哪里讨论不明了。
|
||||
|
||||
这些 IRC 讨论也定下了开发流程本身。LEDE 团队想作出些改变，以使用会合并到主干的阶段开发分支为开端，与 OpenWrt 所使用的“直接提交到主干”方式不同。该项目也将提供基于时间的发行版，并通过只发行已被成功测试的二进制模块来鼓励用户测试，由社区而不是核心开发者在实际的硬件上进行测试。
|
||||
|
||||
最后，这些 IRC 讨论也确定了 LEDE 团队的目的不是用它的宣言吓唬 OpenWrt。Crispin 提到 LEDE 首先是“半公开的”并渐渐做得更公开。 Wich 解释说他希望 LEDE 是“中立的、专业的，并打开大门欢迎 OpenWrt 以便将来的合并”。不幸的是，前期发起工作并不是做得很好。
|
||||
|
||||
在一封邮件中， Fietkau 补充到 OpenWrt 核心开发者确实在任务中遇到瓶颈，像补丁复审和基础设施维护这些事情让他们完成不了其他工作，比如配置下载镜像和改良构建系统。在 LEDE 宣言之后短短几天内，他说，团队成功解决了镜像和构建系统任务，而这些已被搁置多年。
|
||||
|
||||
> 我们在 LEDE 所做的事情很多是基于转移到 Github 的去中心化软件包开发经验，并放弃了软件包应如何被维护的许多控制。这样最终有效减少了我们的工作量，而且我们有了很多更活跃的开发者。
|
||||
|
||||
> 我们真的希望为核心开发做一些类似的事，但是基于我们想作出更大改变的经验，我们觉得在 OpenWrt 项目内做不到。
|
||||
|
||||
修复基础设施也将收获其他好处，他说，就比如改进了用于管理签署发布版本的密码的系统。团队正在考虑在某些情况下非上游补丁的规则，像需要补丁的描述和为什么没有发送到上游的解释。他也提到很多留下的 OpenWrt 开发者表示有兴趣加入 LEDE，相关当事人正试图弄清楚他们是否会重新合并该项目。
|
||||
|
||||
有人希望 LEDE 更为扁平的管理模式和更为透明的分工会在困扰 OpenWrt 的方面取得成功。解决最初的宣言中被诟病的沟通方面的问题会是最大的障碍。如果那个过程处理得好，那么，未来 LEDE 和 OpenWrt 可能能够求同存异并协作。否则，之后两个团队可能一起被迫发展到比以前拥有更少资源的方向，这也许不是开发者或用户想看到的。
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
via: https://lwn.net/Articles/686767/
|
||||
|
||||
作者：[Nathan Willis][a]
|
||||
译者：[XYenChi](https://github.com/XYenChi)
|
||||
校对：[wxy](https://github.com/wxy)
|
||||
|
||||
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||||
|
||||
[a]:https://lwn.net/Articles/686767/
|
||||
[1]:https://openwrt.org/
|
||||
[2]:https://lwn.net/Articles/686180/
|
||||
[3]:https://www.lede-project.org/
|
||||
[4]:https://www.lede-project.org/rules.html
|
||||
[5]:http://lists.infradead.org/pipermail/lede-dev/2016-May/000080.html
|
||||
[6]:https://lwn.net/Articles/686988/
|
||||
[7]:https://lwn.net/Articles/686989/
|
||||
[8]:https://lwn.net/Articles/686990/
|
||||
[9]:https://lwn.net/Articles/686991/
|
||||
[10]:https://lwn.net/Articles/686995/
|
||||
[11]:https://lwn.net/Articles/686996/
|
||||
[12]:https://lwn.net/Articles/686992/
|
||||
[13]:https://lwn.net/Articles/686993/
|
||||
[14]:https://lwn.net/Articles/686998/
|
||||
[15]:https://lwn.net/Articles/687001/
|
||||
[16]:https://lwn.net/Articles/687003/
|
||||
[17]:https://lwn.net/Articles/687004/
|
||||
[18]:http://meetings.lede-project.org/lede-adm/2016/?C=M;O=A
|
||||
[19]:http://meetings.lede-project.org/lede-adm/2016/lede-adm.2016-03-30-11.05.log.html
|
||||
@ -0,0 +1,86 @@
|
||||
促使项目团队作出改变的五步计划
|
||||
============================================================
|
||||
|
||||
|
||||
|
||||
目的是任何团队组建的首要之事。如果一个人足以实现那个目的，那么就没有必要组成团队。而且如果没有重要目标，你根本不需要一个团队。但只要任务需要的专业知识比一个人所拥有的更多，我们就会遇到集体参与的问题——如果处理不当，会使你脱离正轨。
|
||||
|
||||
想象一群人困在洞穴中。没有一个人具备如何出去的全部知识，所以每个人要协作，心路常开，在想要做的事情上尽力配合。当（且仅当）组建了适当的工作团队之后，才能为实现团队的共同目标创造出合适的环境。
|
||||
|
||||
但确实有人觉得待在洞穴中很舒适而且只想待在那里。在组织里，领导者们如何掌控那些实际上抵触改善、待在洞穴中觉得舒适的人？同时该如何找到拥有共同目标但是不在自己组织的人？
|
||||
|
||||
我从事指导国际销售培训，刚开始甚至很少有人认为我的工作有价值。所以，我想出一套使他们信服的战术。那个战术非常成功以至于我决定深入研究它并与各位[分享][2]。
|
||||
|
||||
### 获得支持
|
||||
|
||||
为了建立公司强大的企业文化，有人会反对改变，并且从幕后打压任何改变的提议。他们希望每个人都待在那个舒适的洞穴里。例如，当我第一次接触到海外销售培训，我受到了一些关键人物的严厉阻挠。他们迫使其他人相信某个东京人做不了销售培训——只要基本的产品培训就行了。
|
||||
|
||||
尽管我最终解决了这个问题，但我那时候真的不知道该怎么办。所以，我开始研究顾问们在改变公司里抗拒改变的人的想法这个问题上该如何给出建议。从学者 [Laurence Haughton][3] 的研究中，我发现一般对于改变的提议，组织中 83% 的人最开始不会支持你。大约 17% _会_从一开始就支持你，但是只要看到一个实验案例成功之后，他们觉得这个主意安全可行了，60% 的人会支持你。最后，有部分人会反对任何改变，无论它有多棒。
|
||||
|
||||
我研究的步骤：
|
||||
|
||||
* 从试验项目开始
|
||||
* 开导洞穴人
|
||||
* 快速跟进
|
||||
* 开导洞穴首领
|
||||
* 全局展开
|
||||
|
||||
### 1、 从试验项目开始
|
||||
|
||||
找到高价值且成功率较高的项目——而不是大的、成本高的、周期长的、全局的行动。然后，找到能看到项目价值、理解它的价值并能为之奋斗的关键人物。这些人不应该只是“老好人”或者“朋友”；他们必须相信项目的目标而且拥有推进项目的能力或经验。不要急于求成。只要足够支持你研究并保持进度即可。
|
||||
|
||||
个人而言，我在新加坡的一个小型车辆代理商那里举办了自己的第一场销售研讨会。虽然并不是特别成功，但足以让人们开始讨论销售训练会达到怎样的效果。那时候的我困在洞穴里（那是一份我不想做的工作）。这个试验销售训练是我走出困境的蓝图。
|
||||
|
||||
### 2、 开导洞穴人
|
||||
|
||||
洞穴（CAVE）实际上是我从 Laurence Haughton 那里听来的缩略词。它代表着 Citizens Against Virtually Everything。（LCTT 译注，此处一语双关前文提及的洞穴。）
|
||||
|
||||
你得辨别这些人，因为他们会暗地里阻挠项目的进展，特别是早期脆弱的时候。他们容易黑化：总是消极。他们频繁使用“但是”、“如果”和“为什么”，只是想推脱你。他们询问轻易不可得的细节信息。他们花费过多的时间在问题上，而不是寻找解决方案。他们认为每个失败都是一个趋势。他们总是对人而不是对事。他们作出反对建议的陈述却又不能简单确认。
|
||||
|
||||
避开洞穴人；不要让他们太早加入项目的讨论。他们固守成见，因为他们看不到改变所具有的价值。他们安居于洞穴，所以试着让他们去做些其他事。你应该找出我上面提到那 17% 的人群中的关键人物，那些想要改变的人，并且跟他们开一个非常隐秘的准备会。
|
||||
|
||||
我在五十铃汽车（股东之一是通用汽车公司）的时候，销售训练项目开始于一个销往世界上其他小国家的合资分销商，主要是非洲、南亚、拉丁美洲和中东。我的个人团队由通用汽车公司雪佛兰的人、五十铃产品经理和分公司的销售计划员工组成。隔绝其他任何人于这个圈子之外。
|
||||
|
||||
### 3、 快速跟进
|
||||
|
||||
洞穴人总是慢吞吞的，那么你就迅速行动起来。如果你在他们参与之前就有了小成就的经历，他们对你团队产生消极影响的能力将大大减弱——你要在他们提出之前就解决他们必然反对的问题。再一次，选择一个成功率高的试验项目，很快能出结果的。然后宣传成功，就像广告上的加粗标题。
|
||||
|
||||
当我在新加坡研讨会上所言开始流传时，其他地区开始意识到销售训练的好处。仅在新加坡研讨会之后，我就被派到马来西亚开展了四次以上。
|
||||
|
||||
### 4、 开导洞穴首领
|
||||
|
||||
只要你取得了第一个小项目的成功，就针对能影响洞穴首领的关键人物推荐项目。让团队继续该项目以告诉关键人物成功的经历。一线人员甚至顾客也能提供有力的证明。 洞穴管理者往往只着眼于销量和收益，那么就宣扬项目在降低开支、减少浪费和增加销量方面的价值。
|
||||
|
||||
自新加坡的第一次研讨会及之后，我向直接掌握了五十铃销售渠道的前线销售部门员工和通用汽车真正想看到进展的人极力宣传他们的成功。当他们接受了之后，他们会向上级提出培训请求并让其看到分公司销量的提升。
|
||||
|
||||
### 5、 全局展开
|
||||
|
||||
一旦一把手站在了自己这边，立马向整个组织宣告成功的试验项目。讨论项目的扩展。
|
||||
|
||||
用上面的方法，在 21 年的职业生涯中，我在世界各地超过 60 个国家举办了研讨会。我确实走出了洞穴——并且真的看到了广阔的世界。
|
||||
|
||||
（题图：opensource.com）
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
作者简介：
|
||||
|
||||
Ron McFarland - Ron McFarland 已在日本工作 40 年，从事国际销售、销售管理和在世界范围内扩展销售业务 30 载有余。他曾去过或就职于 80 多个国家。在过去的 14 年里， Ron 为总部位于东京的日本硬件切割厂在美国和欧洲各地建立分销商。
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
via: https://opensource.com/open-organization/17/1/escape-the-cave
|
||||
|
||||
作者：[Ron McFarland][a]
|
||||
译者：[XYenChi](https://github.com/XYenChi)
|
||||
校对：[wxy](https://github.com/wxy)
|
||||
|
||||
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||||
|
||||
[a]:https://opensource.com/users/ron-mcfarland
|
||||
[1]:https://opensource.com/open-organization/17/1/escape-the-cave?rate=dBJIKVJy720uFj0PCfa1JXDZKkMwozxV8TB2qJnoghM
|
||||
[2]:http://www.slideshare.net/RonMcFarland1/creating-change-58994683
|
||||
[3]:http://www.laurencehaughton.com/
|
||||
[4]:https://opensource.com/user/68021/feed
|
||||
[5]:https://opensource.com/open-organization/17/1/escape-the-cave#comments
|
||||
[6]:https://opensource.com/users/ron-mcfarland
|
||||
@ -1,39 +1,38 @@
|
||||
介绍 Flashback，一个互联网模拟工具
|
||||
============================================================
|
||||
|
||||
> Flashback 用于模拟 HTTP 和 HTTPS 资源，如 Web 服务和 REST API，用于测试目的。
|
||||
> Flashback 用于测试目的来模拟 HTTP 和 HTTPS 资源，如 Web 服务和 REST API。
|
||||
|
||||
|
||||
>图片提供： Opensource.com
|
||||
|
||||
|
||||
在 LinkedIn，我们经常开发需要与第三方网站交互的 Web 应用程序。我们还采用自动测试，以确保我们的软件在发布到生产环境之前的质量。然而，测试只是在可靠时才有用。
|
||||
在 LinkedIn，我们经常开发需要与第三方网站交互的 Web 应用程序。我们还采用自动测试，以确保我们的软件在发布到生产环境之前的质量。然而，测试只是在它可靠时才有用。
|
||||
|
||||
考虑到这一点，有外部依赖关系的测试是有很大的问题的，例如在第三方网站上。这些外部网站可能会没有通知地发生改变、遭受停机，或者由于互联网的不可靠性暂时无法访问。
|
||||
|
||||
如果我们的一个测试依赖于能够与第三方网站通信，那么任何故障的原因都很难确定。失败可能是因为 LinkedIn 的内部变更，第三方网站的维护人员进行的外部变更或网络基础设施的问题。你可以想像，与第三方网站的交互可能会有很多失败的原因，因此你可能想要知道，我将如何处理这个问题？
|
||||
如果我们的一个测试依赖于能够与第三方网站通信，那么任何故障的原因都很难确定。失败可能是因为 LinkedIn 的内部变更、第三方网站的维护人员进行的外部变更，或网络基础设施的问题。你可以想像，与第三方网站的交互可能会有很多失败的原因，因此你可能想要知道，我将如何处理这个问题？
|
||||
|
||||
好消息是有许多互联网模拟工具可以帮助。其中一个是 [Betamax][4]。它通过拦截 Web 应用程序发起的 HTTP 连接，之后重放起作用。对于测试，Betamax 可以用以前记录的响应替换 HTTP 上的任何交互，它可以非常可靠地提供这个服务。
|
||||
好消息是有许多互联网模拟工具可以帮助。其中一个是 [Betamax][4]。它通过拦截 Web 应用程序发起的 HTTP 连接，之后进行重放的方式来工作。对于测试，Betamax 可以用以前记录的响应替换 HTTP 上的任何交互，它可以非常可靠地提供这个服务。
|
||||
|
||||
最初，我们选择在 LinkedIn 的自动化测试中使用 Betamax。它工作得很好，但我们遇到了一些问题：
|
||||
|
||||
* 出于安全考虑，我们的测试环境没有接入互联网。然而，与大多数代理一样，Betamax 需要 Internet 连接才能正常运行。
|
||||
* 我们有许多需要使用身份验证协议的情况，例如 OAuth 和 OpenId。其中一些协议需要通过 HTTP 进行复杂的交互。为了模拟它们，我们需要一个复杂的模型来捕获和重放请求。
|
||||
|
||||
为了应对这些挑战，我们决定基于 Betamax 的想法，构建我们自己的互联网模拟工具，名为 Flashback。我们也很自豪地宣布 Flashback 现在是开源的。
|
||||
为了应对这些挑战，我们决定基于 Betamax 的思路，构建我们自己的互联网模拟工具，名为 Flashback。我们也很自豪地宣布 Flashback 现在是开源的。
|
||||
|
||||
### 什么是 Flashback?
|
||||
|
||||
Flashback 用于模拟 HTTP 和 HTTPS 资源，如 Web 服务和 [REST][5] API，用于测试目的。它记录 HTTP/HTTPS 请求并重放以前记录的 HTTP 事务 - 我们称之为“场景”，这样就不需要连接到 Internet 才能完成测试。
|
||||
Flashback 用于测试目的来模拟 HTTP 和 HTTPS 资源，如 Web 服务和 [REST][5] API。它记录 HTTP/HTTPS 请求并重放以前记录的 HTTP 事务 - 我们称之为“<ruby>场景<rt>scene</rt></ruby>”，这样就不需要连接到 Internet 才能完成测试。
|
||||
|
||||
Flashback 也可以根据请求的部分匹配重放场景。它使用的是“匹配规则”。匹配规则将传入请求与先前记录的请求相关联，然后将其用于生成响应。例如，以下代码片段实现了一个基本匹配规则，其中测试方法“匹配”[此 URL][6]的传入请求。
|
||||
|
||||
HTTP 请求通常包含URL、方法、标头和正文。Flashback 允许为这些组件的任意组合定义匹配规则。Flashback 还允许用户向 URL 查询参数，标头和正文添加白名单或黑名单标签。
|
||||
HTTP 请求通常包含 URL、方法、标头和正文。Flashback 允许为这些组件的任意组合定义匹配规则。Flashback 还允许用户向 URL 查询参数，标头和正文添加白名单或黑名单标签。
|
||||
|
||||
例如，在 OAuth 授权流程中，请求查询参数可能如下所示：
|
||||
|
||||
```
|
||||
oauth_consumer_key="jskdjfljsdklfjlsjdfs",
|
||||
oauth_nonce="ajskldfjalksjdflkajsdlfjasldfja;lsdkj",
|
||||
oauth_nonce="ajskldfjalksjdflkajsdlfjasldfja;lsdkj",
|
||||
oauth_signature="asdfjaklsdjflasjdflkajsdklf",
|
||||
oauth_signature_method="HMAC-SHA1",
|
||||
oauth_timestamp="1318622958",
|
||||
@ -41,63 +40,64 @@ oauth_token="asdjfkasjdlfajsdklfjalsdjfalksdjflajsdlfa",
|
||||
oauth_version="1.0"
|
||||
```
|
||||
|
||||
这些值许多将随着每个请求而改变，因为 OAuth 要求客户端每次为 **oauth_nonce** 生成一个新值。在我们的测试中，我们需要验证 **oauth_consumer_key、oauth_signature_method** 和 **oauth_version** 的值，同时确保 **oauth_nonce**、**oauth_signature**、**oauth_timestamp** 和 **oauth_token** 存在于请求中。Flashback 使我们有能力创建我们自己的匹配规则来实现这一目标。此功能允许我们测试随时间变化的数据、签名、令牌等的请求，而客户端没有任何更改。
|
||||
这些值许多将随着每个请求而改变，因为 OAuth 要求客户端每次为 `oauth_nonce` 生成一个新值。在我们的测试中，我们需要验证 `oauth_consumer_key`、`oauth_signature_method` 和 `oauth_version` 的值，同时确保 `oauth_nonce`、`oauth_signature`、`oauth_timestamp` 和 `oauth_token` 存在于请求中。Flashback 使我们有能力创建我们自己的匹配规则来实现这一目标。此功能允许我们测试随时间变化的数据、签名、令牌等的请求，而客户端没有任何更改。
|
||||
|
||||
这种灵活的匹配和在不连接互联网的情况下运行的功能是将 Flashback 与其他模拟解决方案分开的属性。其他一些显著特点包括：
|
||||
这种灵活的匹配和在不连接互联网的情况下运行的功能是 Flashback 与其他模拟解决方案不同的特性。其他一些显著特点包括：
|
||||
|
||||
* Flashback 是一种跨平台和跨语言解决方案，能够测试 JVM（Java虚拟机）和非 JVM（C++、Python等）应用程序。
|
||||
* Flashback 是一种跨平台和跨语言解决方案，能够测试 JVM（Java虚拟机）和非 JVM（C++、Python 等）应用程序。
|
||||
* Flashback 可以随时生成 SSL/TLS 证书，以模拟 HTTPS 请求的安全通道。
|
||||
|
||||
### 如何记录 HTTP 事务
|
||||
|
||||
使用 Flashback 记录 HTTP 事务以便稍后重放是一个比较简单的过程。在我们深入了解流程之前，我们首先列出一些术语：
|
||||
|
||||
* **场景** 存储以前记录的 HTTP 事务 (以 JSON 格式)，它可以在以后重放。例如，这里是一个[Flashback 场景][1]示例。
|
||||
* **根路径** 是包含 Flashback 场景数据的目录的文件路径。
|
||||
* **场景名称** 是给定场景的名称。
|
||||
* **场景模式** 是使用场景的模式, 即“录制”或“重放”。
|
||||
* **匹配规则** 确定传入的客户端请求是否与给定场景的内容匹配的规则。
|
||||
* **Flashback 代理** 是一个 HTTP 代理，共有录制和重放两种操作模式。
|
||||
* **主机** 和 **端口** 是代理主机和端口。
|
||||
* `Scene` ：场景存储以前记录的 HTTP 事务 (以 JSON 格式)，它可以在以后重放。例如，这里是一个[Flashback 场景][1]示例。
|
||||
* `Root Path` ：根路径是包含 Flashback 场景数据的目录的文件路径。
|
||||
* `Scene Name` ：场景名称是给定场景的名称。
|
||||
* `Scene Mode` ：场景模式是使用场景的模式, 即“录制”或“重放”。
|
||||
* `Match Rule` ：匹配规则确定传入的客户端请求是否与给定场景的内容匹配的规则。
|
||||
* `Flashback Proxy` ：Flashback 代理是一个 HTTP 代理，共有录制和重放两种操作模式。
|
||||
* `Host` 和 `Port` ：代理主机和端口。
|
||||
|
||||
为了录制场景，你必须向目的地址发出真实的外部请求，然后 HTTPS 请求和响应将使用你指定的匹配规则存储在场景中。在录制时，Flashback 的行为与典型的 MITM（中间人）代理完全相同 - 只有在重放模式下，连接流和数据流仅限于客户端和代理之间。
|
||||
|
||||
要实际看下 Flashback，让我们创建一个场景，通过执行以下操作捕获与 example.org 的交互：
|
||||
|
||||
1\. 取回 Flashback 的源码：
|
||||
1、 取回 Flashback 的源码：
|
||||
|
||||
```
|
||||
git clone https://github.com/linkedin/flashback.git
|
||||
```
|
||||
|
||||
2\. 启动 Flashback 管理服务器：
|
||||
2、 启动 Flashback 管理服务器：
|
||||
|
||||
```
|
||||
./startAdminServer.sh -port 1234
|
||||
```
|
||||
|
||||
3\. 注意上面的 Flashback 将在本地端口 5555 上启动录制模式。匹配规则需要完全匹配（匹配 HTTP 正文、标题和 URL）。场景将存储在 **/tmp/test1** 下。
|
||||
4\. Flashback 现在可以记录了，所以用它来代理对 example.org 的请求：
|
||||
3、 注意上面的 Flashback 将在本地端口 5555 上启动录制模式。匹配规则需要完全匹配（匹配 HTTP 正文、标题和 URL）。场景将存储在 `/tmp/test1` 下。
|
||||
|
||||
4、 Flashback 现在可以记录了，所以用它来代理对 example.org 的请求：
|
||||
|
||||
```
|
||||
curl http://www.example.org -x localhost:5555 -X GET
|
||||
```
|
||||
|
||||
5\. Flashback可以（可选）在一个记录中记录多个请求。要完成录制，[关闭 Flashback][8]。
|
||||
5、 Flashback 可以（可选）在一个记录中记录多个请求。要完成录制，[关闭 Flashback][8]。
|
||||
|
||||
6\. 要验证已记录的内容，我们可以在输出目录（**/tmp/test1**）中查看场景的内容。它应该[包含以下内容][9]。
|
||||
6、 要验证已记录的内容，我们可以在输出目录（`/tmp/test1`）中查看场景的内容。它应该[包含以下内容][9]。
|
||||
|
||||
这也很容易[在 Java 代码中使用 Flashback][10]。
|
||||
[在 Java 代码中使用 Flashback][10]也很容易。
|
||||
|
||||
### 如何重放 HTTP 事务
|
||||
|
||||
要重放先前存储的场景，请使用与录制时使用的相同的基本设置。唯一的区别是[将“场景模式”设置为上述步骤 3 中的“播放”][11]。
|
||||
|
||||
验证响应来自场景而不是外部源的一种方法是在你执行步骤 1 到 6 时临时禁用 Internet 连接。另一种方法是修改场景文件，看看响应是否与文件中的相同。
|
||||
验证响应来自场景而不是外部源的一种方法，是在你执行步骤 1 到 6 时临时禁用 Internet 连接。另一种方法是修改场景文件，看看响应是否与文件中的相同。
|
||||
|
||||
这是[ Java 中的一个例子][12]。
|
||||
这是 [Java 中的一个例子][12]。
|
||||
|
||||
### 如何记录并重播HTTPS事务
|
||||
### 如何记录并重播 HTTPS 事务
|
||||
|
||||
使用 Flashback 记录并重放 HTTPS 事务的过程非常类似于 HTTP 事务的过程。但是，需要特别注意用于 HTTPS SSL 组件的安全证书。为了使 Flashback 作为 MITM 代理，必须创建证书颁发机构（CA）证书。在客户端和 Flashback 之间创建安全通道时将使用此证书，并允许 Flashback 检查其代理的 HTTPS 请求中的数据。然后将此证书存储为受信任的源，以便客户端在进行调用时能够对 Flashback 进行身份验证。有关如何创建证书的说明，有很多[类似这样][13]的资源是非常有帮助的。大多数公司都有自己的管理和获取证书的内部策略 - 请务必用你们自己的方法。
|
||||
|
||||
@ -105,25 +105,25 @@ curl http://www.example.org -x localhost:5555 -X GET
|
||||
|
||||
一旦涉及安全证书，HTTP 和 HTTPS 之间在记录设置方面的唯一区别是添加了一些其他参数。
|
||||
|
||||
* **RootCertificateInputStream**： 表示 CA 证书文件路径或流。
|
||||
* **RootCertificatePassphrase**： 为CA证书创建的密码。
|
||||
* **CertificateAuthority**： CA证书的属性
|
||||
* `RootCertificateInputStream`： 表示 CA 证书文件路径或流。
|
||||
* `RootCertificatePassphrase`： 为 CA 证书创建的密码。
|
||||
* `CertificateAuthority`： CA 证书的属性
|
||||
|
||||
[查看 Flashback 中用于记录 HTTPS 事务的代码][14]，它包括上述条款。
|
||||
[查看 Flashback 中用于记录 HTTPS 事务的代码][14]，它包括上述条目。
|
||||
|
||||
使用 Flashback 重放 HTTPS 事务使用与录制相同的过程。唯一的区别是场景模式设置为“播放”。这在[此代码][15]中演示。
|
||||
用 Flashback 重放 HTTPS 事务的过程与录制相同。唯一的区别是场景模式设置为“播放”。这在[此代码][15]中演示。
|
||||
|
||||
### 支持动态修改
|
||||
|
||||
为了测试灵活性，Flashback 允许你动态地更改场景和匹配规则。动态更改场景允许使用不同的响应（如 success、**time_out**、**rate_limit** 等）测试相同的请求。[场景更改][16]仅适用于我们已经 POST 更新外部资源的场景。以下图为例。
|
||||
为了测试灵活性，Flashback 允许你动态地更改场景和匹配规则。动态更改场景允许使用不同的响应（如 `success`、`time_out`、`rate_limit` 等）测试相同的请求。[场景更改][16]仅适用于我们已经 POST 更新外部资源的场景。以下图为例。
|
||||
|
||||
|
||||
|
||||
这能够[更改匹配规则][17]动态地允许我们测试复杂的场景。例如，我们有一个情况，要求我们测试 Twitter 的公共和私有资源的 HTTP 调用。对于公共资源，HTTP 请求是不变的，所以我们可以使用 “MatchAll” 规则。然而，对于私人资源，我们需要使用 OAuth 消费者密码和 OAuth 访问令牌来签名请求。这些请求包含大量具有不可预测值的参数，因此静态 MatchAll 规则将无法正常工作。
|
||||
能够动态[更改匹配规则][17]可以使我们测试复杂的场景。例如，我们有一个使用情况，要求我们测试 Twitter 的公共和私有资源的 HTTP 调用。对于公共资源，HTTP 请求是不变的，所以我们可以使用 “MatchAll” 规则。然而，对于私人资源，我们需要使用 OAuth 消费者密码和 OAuth 访问令牌来签名请求。这些请求包含大量具有不可预测值的参数，因此静态 MatchAll 规则将无法正常工作。
|
||||
|
||||
### 使用案例
|
||||
|
||||
在 LinkedIn，Flashback 主要用于在集成测试中模拟不同的互联网提供商，如下图所示。第一张图展示了通过代理层与 LinkedIn 生产数据中心内的内部服务，该服务与互联网提供商（如 Google）进行交互。我们想在测试环境中测试这个内部服务。
|
||||
在 LinkedIn，Flashback 主要用于在集成测试中模拟不同的互联网提供商，如下图所示。第一张图展示了 LinkedIn 生产数据中心内的一个内部服务，通过代理层，与互联网提供商（如 Google）进行交互。我们想在测试环境中测试这个内部服务。
|
||||
|
||||
|
||||
|
||||
@ -137,9 +137,9 @@ curl http://www.example.org -x localhost:5555 -X GET
|
||||
|
||||
### 未来方向
|
||||
|
||||
我们希望将来可以支持非 HTTP 协议（如 FTP 或 JDBC），甚至可以让用户使用 MITM 代理框架来自行注入自己的定制协议。我们将继续改进 Flashback 设置 API，使其支持非 Java 语言更容易。
|
||||
我们希望将来可以支持非 HTTP 协议（如 FTP 或 JDBC），甚至可以让用户使用 MITM 代理框架来自行注入自己的定制协议。我们将继续改进 Flashback 设置 API，使其更容易支持非 Java 语言。
|
||||
|
||||
### 现在作为一个开源项目可用
|
||||
### 现在为一个开源项目
|
||||
|
||||
我们很幸运能够在 GTAC 2015 上发布 Flashback。在展会上，有几名观众询问是否将 Flashback 作为开源项目发布，以便他们可以将其用于自己的测试工作。
|
||||
|
||||
@ -147,25 +147,28 @@ curl http://www.example.org -x localhost:5555 -X GET
|
||||
|
||||
<iframe allowfullscreen="" frameborder="0" height="315" src="https://www.youtube.com/embed/6gPNrujpmn0?origin=https://opensource.com&enablejsapi=1" width="560" id="6gPNrujpmn0" data-sdi="true"></iframe>
|
||||
|
||||
我们很高兴地宣布，Flashback 现在以 BSD（Berkeley Software Distribution）双条款许可证开源。要开始使用，请访问[ Flashback GitHub 仓库][18]。
|
||||
我们很高兴地宣布，Flashback 现在以 BSD 两句版许可证开源。要开始使用，请访问 [Flashback GitHub 仓库][18]。
|
||||
|
||||
_该文原始发表在[LinkedIn 工程博客上][2]。转载许可_
|
||||
_该文原始发表在[LinkedIn 工程博客上][2]。获得转载许可_
|
||||
|
||||
### 致谢
|
||||
|
||||
Flashback 由 [Shangshang Feng][19]、[Yabin Kang][20] 和 [Dan Vinegrad][21] 创建，并受到 [Betamax][22] 启发。特别感谢 [Hwansoo Lee][23]、[Eran Leshem][24]、[Kunal Kandekar][25]、[Keith Dsouza][26] 和 [Kang Wang][27] 帮助审阅代码。同样感谢我们的管理层 - [Byron Ma][28]、[Yaz Shimizu][29]、[Yuliya Averbukh][30]、[Christopher Hazlett][31] 和 [Brandon Duncan][32] - 感谢他们在开发和开源 Flashback 中的支持。
|
||||
|
||||
|
||||
（题图：Opensource.com）
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
作者简介：
|
||||
|
||||
Shangshang Feng - Shangshang 是 LinkedIn 纽约市办公室的高级软件工程师。他花了三年半的时间在 LinkedIn 的网关平台工作。在加入 LinkedIn 之前，他曾在 Thomson Reuters 和 ViewTrade 证券的基础设施团队工作。
|
||||
Shangshang Feng - Shangshang 是 LinkedIn 纽约市办公室的高级软件工程师。在 LinkedIn 他从事了三年半的网关平台工作。在加入 LinkedIn 之前，他曾在 Thomson Reuters 和 ViewTrade 证券的基础设施团队工作。
|
||||
|
||||
---------
|
||||
|
||||
via: https://opensource.com/article/17/4/flashback-internet-mocking-tool
|
||||
|
||||
作者：[ Shangshang Feng][a]
|
||||
作者：[Shangshang Feng][a]
|
||||
译者：[geekpi](https://github.com/geekpi)
|
||||
校对：[jasminepeng](https://github.com/jasminepeng)
|
||||
|
||||
@ -1,62 +1,61 @@
|
||||
如何在一个 U 盘上安装多个 Linux 发行版
|
||||
============================================================
|
||||
|
||||
> 概要：本教程介绍如何在一个 U 盘上安装多个 Linux 发行版。这样，你可以在单个 U 盘上享受多个<ruby>现场版<rt>live</rt></ruby> Linux 发行版了。
|
||||
|
||||
_概要：本教程介绍如何在一个 U 盘上安装多个 Linux 发行版。这样，你可以在单个 U 盘上享受多个 live Linux 发行版了。_
|
||||
我喜欢通过 U 盘尝试不同的 Linux 发行版。它让我可以在真实的硬件上测试操作系统，而不是虚拟化的环境中。此外，我可以将 USB 插入任何系统（比如 Windows 系统），做任何我想要的事情，以及享受相同的 Linux 体验。而且，如果我的系统出现问题，我可以使用 U 盘恢复！
|
||||
|
||||
我喜欢通过 U 盘尝试不同的 Linux 发行版。它让我可以选择在真实的硬件上测试操作系统，而不是虚拟化的环境。此外，我可以将 USB 插入任何系统（读 Windows），做任何我想要的，以及享受相同的 Linux 体验。是的，如果我的系统出现问题，我可以使用 U 盘恢复！
|
||||
|
||||
创建单个[可启动的 Linux USB ][8]很简单，你只需下载一个 ISO 文件并将其刻录到 U 盘。但是，如果你想尝试多个 Linux 发行版呢？你可以使用多个 U 盘，也可以覆盖同一个 U 盘以尝试其他 Linux 发行版。但这两种方法都不是很方便。
|
||||
创建单个[可启动的现场版 Linux USB][8] 很简单，你只需下载一个 ISO 文件并将其刻录到 U 盘。但是，如果你想尝试多个 Linux 发行版呢？你可以使用多个 U 盘，也可以覆盖同一个 U 盘以尝试其他 Linux 发行版。但这两种方法都不是很方便。
|
||||
|
||||
那么，有没有在单个 U 盘上安装多个 Linux 发行版的方式呢？我们将在本教程中看到如何做到这一点。
|
||||
|
||||
### 如何创建有多个 Linux 发行版的可启动 USB
|
||||
### 如何创建有多个 Linux 发行版的可启动 USB
|
||||
|
||||
|
||||
|
||||
我们有一个工具_通过在单个 U 盘上保留多个 Linux 发行版_来做到这个。你所需要做的是选择要安装的发行版。在本教程中，我们将介绍_如何在 U 盘中安装多个 Linux 发行版_。
|
||||
我们有一个工具正好可以做到_在单个 U 盘上保留多个 Linux 发行版_。你所需要做的只是选择要安装的发行版。在本教程中，我们将介绍_如何在 U 盘中安装多个 Linux 发行版_用于<ruby>现场会话<rt>live session</rt></ruby>。
|
||||
|
||||
要确保你有一个足够大的 U 盘，以便在它上面安装多个 Linux 发行版，因此一个 8 GB 的 U 盘应该足够用于三四个 Linux 发行版。
|
||||
要确保你有一个足够大的 U 盘，以便在它上面安装多个 Linux 发行版，一个 8 GB 的 U 盘应该足够用于三四个 Linux 发行版。
|
||||
|
||||
### 步骤 1
|
||||
#### 步骤 1
|
||||
|
||||
[MultiBootUSB][9] 是一个免费开源跨平台应用程序，允许你创建具有多个 Linux 发行版的 U 盘。它还支持在任何时候卸载任何发行版，所以你可以回收驱动器上的空间用于另一个发行版。
|
||||
[MultiBootUSB][9] 是一个自由、开源的跨平台应用程序，允许你创建具有多个 Linux 发行版的 U 盘。它还支持在任何时候卸载任何发行版，以便你回收驱动器上的空间用于另一个发行版。
|
||||
|
||||
下载 .deb 包并双击安装。
|
||||
|
||||
[下载 MultiBootUSB][10]
|
||||
|
||||
### 步骤 2
|
||||
#### 步骤 2
|
||||
|
||||
推荐的文件系统是 FAT32，因此在创建多引导 U 盘之前，请确保格式化 U 盘。
|
||||
|
||||
### 步骤 3
|
||||
#### 步骤 3
|
||||
|
||||
下载要安装的 Linux 发行版的 ISO 镜像。
|
||||
|
||||
### 步骤 4
|
||||
#### 步骤 4
|
||||
|
||||
完成这些后，启动 MultiBootUSB。
|
||||
|
||||
|
||||
|
||||
主页面要求你选择 U 盘和你打算放到 U 盘上的 Linux 发行版镜像文件。
|
||||
主屏幕要求你选择 U 盘和你打算放到 U 盘上的 Linux 发行版镜像文件。
|
||||
|
||||
MultiBootUSB 支持 Ubuntu、Fedora 和 Debian 发行版持久化，这意味着对 Linux 发行版的 live 版本所做的更改将保存到 USB 上。
|
||||
MultiBootUSB 支持 Ubuntu、Fedora 和 Debian 发行版的持久化，这意味着对 Linux 发行版的现场版本所做的更改将保存到 USB 上。
|
||||
|
||||
你可以通过拖动 MultiBootUSB 选项卡下的滑块来选择持久化大小。持久化为你提供了在运行时将更改保存到 U 盘的选项。
|
||||
|
||||
|
||||
|
||||
### 步骤 5
|
||||
#### 步骤 5
|
||||
|
||||
单击安装发行版选项并继续安装。在显示成功的安装消息之前，需要一些时间才能完成。
|
||||
单击“安装发行版”选项并继续安装。在显示成功的安装消息之前，需要一些时间才能完成。
|
||||
|
||||
你现在可以在已安装部分中看到发行版了。对于另外的操作系统，重复该过程。这是我安装 Ubuntu 16.10 和 Fedora 24 后的样子。
|
||||
|
||||
|
||||
|
||||
### 步骤 6
|
||||
#### 步骤 6
|
||||
|
||||
下次通过 USB 启动时，我可以选择任何一个发行版。
|
||||
|
||||
@ -66,7 +65,7 @@ MultiBootUSB 支持 Ubuntu、Fedora 和 Debian 发行版持久化，这意味着
|
||||
|
||||
### 最后的话
|
||||
|
||||
MultiBootUSB 真的很方便在 U 盘上安装多个 Linux 发行版。只需点击几下，我就有两个我最喜欢的操作系统的工作盘了，我可以在任何系统上启动它们。
|
||||
MultiBootUSB 真的很便于在 U 盘上安装多个 Linux 发行版。只需点击几下，我就有两个我最喜欢的操作系统的工作盘了，我可以在任何系统上启动它们。
|
||||
|
||||
如果你在安装或使用 MultiBootUSB 时遇到任何问题，请在评论中告诉我们。
|
||||
|
||||
@ -74,9 +73,9 @@ MultiBootUSB 真的很方便在 U 盘上安装多个 Linux 发行版。只需点
|
||||
|
||||
via: https://itsfoss.com/multiple-linux-one-usb/
|
||||
|
||||
作者：[Ambarish Kumar ][a]
|
||||
作者：[Ambarish Kumar][a]
|
||||
译者：[geekpi](https://github.com/geekpi)
|
||||
校对：[校对者ID](https://github.com/校对者ID)
|
||||
校对：[wxy](https://github.com/wxy)
|
||||
|
||||
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||||
|
||||
@ -0,0 +1,51 @@
|
||||
见多识广的 Pornhub 人工智能比你认识更多的 XXX 明星
|
||||
============================================================
|
||||
|
||||
|
||||
|
||||
你有没有想过，之所以能够根据自己不同兴趣的组合搜索到需要的视频，是因为有那些每日浏览无数视频内容且对它们进行分类和标记的可怜人存在，然而这些看不见的英雄们却在人工智能面前变得英雄无用武之地。
|
||||
|
||||
世界上最大的 XXX 电影分享网站 Pornhub 宣布，它将推出新的 AI 模型，利用计算机视觉技术自动检测和识别 XXX 明星的名字。
|
||||
|
||||
根据 X-rated 网站的消息，目前该算法经过训练后已经通过简单的扫描和对镜头的理解，可以识别超过 1 万名 XXX 明星。Pornhub 说，通过向此 AI 模型输入数千个视频和 XXX 明星的正式照片，以让它学习如何返回准确的名字。
|
||||
|
||||
为了减小错误，这个成人网站将向用户求证由 AI 提供的标签和分类是否合适。用户可以根据结果的准确度，提出支持或是反对。这将会让算法变得更加智能。
|
||||
|
||||
|
||||
|
||||
“现在，用户可以根据自身喜好寻找指定的 XXX 明星，我们也能够返回给用户尽可能精确的搜索结果，” PornHub 副总裁 Corey Price 说。“毫无疑问，我们的模型也将在未来的发展中扮演关键角色，尤其是考虑到每天有超过 1 万个的视频添加到网站上。”
|
||||
|
||||
“事实上，在过去的一个月里，我们测试了这个模型的测试版本，它（每天）可以扫描 5 万段视频，并且向视频添加或者移除标签。”
|
||||
|
||||
除了识别表演者，该算法还能区分不同类别的内容：比如在 “Public” 类别下的是户外拍摄的视频，以及 “Blonde” 类别下的视频应该至少有名金发女郎。
|
||||
|
||||
XXX 公司计划明年在 AI 模型的帮助下，对全部 500 万个视频编目，希望能让用户更容易找到与他们的期望最接近的视频片段。
|
||||
|
||||
早先就有研究人员借助计算机视觉算法对 XXX 电影进行描述。之前就有一名开发者使用微软的人工智能技术来构建这个机器人，它可以整天[观察和解读][2]各种内容。
|
||||
|
||||
Pornhub 似乎让这一想法更进一步，这些那些遍布全球的视频审看员的噩梦。
|
||||
|
||||
虽然人工智能被发展到这个方面可能会让你感觉有些不可思议，但 XXX 业因其对搜索引擎优化技术的狂热追求而[闻名][3]。
|
||||
|
||||
事实上，[成人内容服务][4]一直以来都[有广泛市场][5]，且[受众不分年龄][6]，这也是这些公司盈利的重要组成部分。
|
||||
|
||||
但是，这些每日阅片无数、兢兢业业为其分类的人们可能很快就会成为自动化威胁的牺牲品。但从好的一面看，他们终于有机会坐下来[让自动化为他们工作][7]。
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
via: https://thenextweb.com/artificial-intelligence/2017/10/11/pornhub-ai-watch-tag/
|
||||
|
||||
作者：[MIX][a]
|
||||
译者：[东风唯笑](https://github.com/dongfengweixiao)
|
||||
校对：[wxy](https://github.com/wxy)
|
||||
|
||||
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||||
|
||||
[a]:https://thenextweb.com/author/dimitarmihov/
|
||||
[1]:https://thenextweb.com/author/dimitarmihov/
|
||||
[2]:https://thenextweb.com/shareables/2017/03/03/porn-bot-microsoft-ai-pornhub/?amp=1
|
||||
[3]:https://moz.com/ugc/yes-dear-there-is-porn-seo-and-we-can-learn-a-lot-from-it
|
||||
[4]:https://www.upwork.com/job/Native-English-Speaker-Required-For-Video-Titles-Descriptions_~0170f127db07b9232b/
|
||||
[5]:https://www.quora.com/How-do-adult-sites-practice-SEO
|
||||
[6]:https://www.blackhatworld.com/seo/adult-looking-for-content-writer-for-porn-site.502731/
|
||||
[7]:https://thenextweb.com/gear/2017/07/07/fleshlight-launch-review-masturbation/?amp=1
|
||||
@ -1,93 +0,0 @@
|
||||
Translating by ZH1122
|
||||
The changing face of the hybrid cloud
|
||||
============================================================
|
||||
|
||||
### Terms and concepts around cloud computing are still new, but evolving.
|
||||
|
||||
|
||||
|
||||
Image credits :
|
||||
|
||||
[Flickr user: theaucitron][9] (CC BY-SA 2.0)
|
||||
|
||||
Depending upon the event you use to start the clock, cloud computing is only a little more than 10 years old. Some terms and concepts around cloud computing that we take for granted today are newer still. The National Institute of Standards and Technology (NIST) document that defined now-familiar cloud terminology—such as Infrastructure-as-a-Service (IaaS)—was only published in 2011, although it widely circulated in draft form for a while before that.
|
||||
|
||||
Among other definitions in that document was one for _hybrid cloud_ . Looking at how that term has shifted during the intervening years is instructive. Cloud-based infrastructures have moved beyond a relatively simplistic taxonomy. Also, it highlights how priorities familiar to adopters of open source software—such as flexibility, portability, and choice—have made their way to the hybrid cloud.
|
||||
|
||||
Explore the open source cloud
|
||||
|
||||
* [What is the cloud?][1]
|
||||
|
||||
* [What is OpenStack?][2]
|
||||
|
||||
* [What is Kubernetes?][3]
|
||||
|
||||
* [Why the operating system matters for containers][4]
|
||||
|
||||
* [Keeping Linux containers safe and secure][5]
|
||||
|
||||
NIST's original hybrid cloud definition was primarily focused on cloud bursting, the idea that you might use on-premise infrastructure to handle a base computing load, but that you could "burst" out to a public cloud if your usage spiked. Closely related were efforts to provide API compatibility between private clouds and public cloud providers and even to create spot markets to purchase capacity wherever it was cheapest.
|
||||
|
||||
Implicit in all this was the idea of the cloud as a sort of standardized compute utility with clear analogs to the electrical grid, a concept probably most popularized by author Nick Carr in his book [_The Big Switch_][10] . It made for a good story but, even early on, the [limitations of the analogy became evident][11]. Computing isn't a commodity in the manner of electricity. One need look no further than the proliferation of new features by all of the major public cloud providers—as well as in open source cloud software such as OpenStack—to see that many users aren't simply looking for generic computing cycles at the lowest price.
|
||||
|
||||
The cloud bursting idea also largely ignored the reality that computing is usually associated with data and you can't just move large quantities of data around instantaneously without incurring big bandwidth bills and having to worry about the length of time those transfers take. Dave McCrory coined the term _data gravity_ to describe this limitation.
|
||||
|
||||
Given this rather negative picture I've painted, why are we talking about hybrid clouds so much today?
|
||||
|
||||
As I've discussed, hybrid clouds were initially thought of mostly in the context of cloud bursting. And cloud bursting perhaps most emphasized rapid, even real-time, shifts of workloads from one cloud to another; however, hybrid clouds also implied application and data portability. Indeed, as [I wrote in a CNET post][12] back in 2011: "I think we do ourselves a disservice by obsessing too much with 'automagical' workload shifting—when what we really care about is the ability to just move from one place to another if a vendor isn't meeting our requirements or is trying to lock us in."
|
||||
|
||||
Since then, thinking about portability across clouds has evolved even further.
|
||||
|
||||
Linux always has been a key component of cloud portability because it can run on everything from bare-metal to on-premise virtualized infrastructures, and from private clouds to public clouds. Linux provides a well-established, reliable platform with a stable API contract against which applications can be written.
|
||||
|
||||
The widespread adoption of containers has further enhanced the ability of Linux to provide application portability across clouds. By providing an image that also contains an application's dependencies, a container provides portability and consistency as applications move from development, to testing, and finally to production.
|
||||
|
||||
Linux containers can be applied in many different ways to problems where ultimate portability, configurability, and isolation are needed. This is true whether running on-premise, in a public cloud, or a hybrid of the two.
|
||||
|
||||
Container tools use an image-based deployment model. This makes sharing an application or set of services with all of their dependencies across multiple environments easy.
|
||||
|
||||
Specifications developed under the auspices of the Open Container Initiative (OCI) work together to define the contents of a container image and those dependencies, environments, arguments, and so forth necessary for the image to be run properly. As a result of these standardization efforts, the OCI has opened the door for many other tooling efforts that can now depend on stable runtime and image specs.
|
||||
|
||||
At the same time, distributed storage can provide data portability across clouds using open source technologies such as Gluster and Ceph. Physical constraints will always impose limits on how quickly and easily data can be moved from one location to another; however, as organizations deploy and use different types of infrastructure, they increasingly desire open, software-defined storage platforms that scales across physical, virtual, and cloud resources.
|
||||
|
||||
This is especially the case as data storage requirements grow rapidly, because of trends in predictive analytics, internet-of-things, and real-time monitoring. In [one 2016 study][13], 98% of IT decision makers said a more agile storage solution could benefit their organization. In the same study, they listed inadequate storage infrastructure as one of the greatest frustrations that their organizations experience.
|
||||
|
||||
And it's really this idea of providing appropriate portability and consistency across a heterogeneous set of computing capabilities and resources that embodies what hybrid cloud has become. Hybrid cloud is not so much about using a private cloud and a public cloud in concert for the same applications. It's about using a set of services of many types, some of which are probably built and operated by your IT department, and some of which are probably sourced externally.
|
||||
|
||||
They'll probably be a mix of Software-as-a-Service applications, such as email and customer relationship management. Container platforms, orchestrated by open source software such as Kubernetes, are increasingly popular for developing new applications. Your organization likely is using one of the big public cloud providers for _something_ . And you're almost certain to be operating some of your own infrastructure, whether it's a private cloud or more traditional on-premise infrastructure.
|
||||
|
||||
This is the face of today's hybrid cloud, which really can be summed up as choice—choice to select the most appropriate types of infrastructure and services, and choice to move applications and data from one location to another when you want to.
|
||||
|
||||
**_Also read: [Multi-cloud vs. hybrid cloud: What's the difference?][6]_**
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
作者简介：
|
||||
|
||||
Gordon Haff is Red Hat’s cloud evangelist, is a frequent and highly acclaimed speaker at customer and industry events, and helps develop strategy across Red Hat’s full portfolio of cloud solutions. He is the author of Computing Next: How the Cloud Opens the Future in addition to numerous other publications. Prior to Red Hat, Gordon wrote hundreds of research notes, was frequently quoted in publications like The New York Times on a wide range of IT topics, and advised clients on product and marketing strategies. Earlier in his career, he was responsible for bringing a wide range of computer systems, from minicomputers to large UNIX servers, to market while at Data General. Gordon has engineering degrees from MIT and Dartmouth and an MBA from Cornell’s Johnson School.
|
||||
|
||||
|
||||
via: https://opensource.com/article/17/7/hybrid-cloud
|
||||
|
||||
作者：[ Gordon Haff (Red Hat) ][a]
|
||||
译者：[译者ID](https://github.com/译者ID)
|
||||
校对：[校对者ID](https://github.com/校对者ID)
|
||||
|
||||
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||||
|
||||
[a]:https://opensource.com/users/ghaff
|
||||
[1]:https://opensource.com/resources/cloud?src=cloud_resource_menu1
|
||||
[2]:https://opensource.com/resources/what-is-openstack?src=cloud_resource_menu2
|
||||
[3]:https://opensource.com/resources/what-is-kubernetes?src=cloud_resource_menu3
|
||||
[4]:https://opensource.com/16/12/yearbook-why-operating-system-matters?src=cloud_resource_menu4
|
||||
[5]:https://opensource.com/business/16/10/interview-andy-cathrow-anchore?src=cloud_resource_menu5
|
||||
[6]:https://enterprisersproject.com/article/2017/7/multi-cloud-vs-hybrid-cloud-whats-difference
|
||||
[7]:https://opensource.com/article/17/7/hybrid-cloud?rate=ztmV2D_utD03cID1u41Al08w0XFm6rXXwCJdTwqI4iw
|
||||
[8]:https://opensource.com/user/21220/feed
|
||||
[9]:https://www.flickr.com/photos/theaucitron/5810163712/in/photolist-5p9nh3-6EkSKG-6EgGEF-9hYBcr-abCSpq-9zbjDz-4PVqwm-9RqBfq-abA2T4-4nXfwv-9RQkdN-dmjSdA-84o2ER-abA2Wp-ehyhPC-7oFYrc-4nvqBz-csMQXb-nRegFf-ntS23C-nXRyaB-6Xw3Mq-cRMaCq-b6wkkP-7u8sVQ-yqcg-6fTmk7-bzm3vU-6Xw3vL-6EkzCQ-d3W8PG-5MoveP-oMWsyY-jtMME6-XEMwS-2SeRXT-d2hjzJ-p2ZZVZ-7oFYoX-84r6Mo-cCizvm-gnnsg5-77YfPx-iDjqK-8gszbW-6MUZEZ-dhtwtk-gmpTob-6TBJ8p-mWQaAC/
|
||||
[10]:http://www.nicholascarr.com/?page_id=21
|
||||
[11]:https://www.cnet.com/news/there-is-no-big-switch-for-cloud-computing/
|
||||
[12]:https://www.cnet.com/news/cloudbursting-or-just-portable-clouds/
|
||||
[13]:https://www.redhat.com/en/technologies/storage/vansonbourne
|
||||
[14]:https://opensource.com/users/ghaff
|
||||
[15]:https://opensource.com/users/ghaff
|
||||
@ -1,3 +1,5 @@
|
||||
translating---geekpi
|
||||
|
||||
Our journey from Redis 2 to Redis 3 while not taking the site down.
|
||||
============================================================
|
||||
|
||||
|
||||
@ -1,216 +0,0 @@
|
||||
[Concurrent Servers: Part 1 - Introduction][18]
|
||||
============================================================
|
||||
|
||||
GitFuture is Translating
|
||||
|
||||
This is the first post in a series about concurrent network servers. My plan is to examine several popular concurrency models for network servers that handle multiple clients simultaneously, and judge those models on scalability and ease of implementation. All servers will listen for socket connections and implement a simple protocol to interact with clients.
|
||||
|
||||
All posts in the series:
|
||||
|
||||
* [Part 1 - Introduction][7]
|
||||
|
||||
* [Part 2 - Threads][8]
|
||||
|
||||
* [Part 3 - Event-driven][9]
|
||||
|
||||
### The protocol
|
||||
|
||||
The protocol used throughout this series is very simple, but should be sufficient to demonstrate many interesting aspects of concurrent server design. Notably, the protocol is _stateful_ - the server changes internal state based on the data clients send, and its behavior depends on that internal state. Not all protocols all stateful - in fact, many protocols over HTTP these days are stateless - but stateful protocols are sufficiently common to warrant a serious discussion.
|
||||
|
||||
Here's the protocol, from the server's point of view:
|
||||
|
||||
|
||||
|
||||
In words: the server waits for a new client to connect; when a client connects, the server sends it a `*` character and enters a "wait for message state". In this state, the server ignores everything the client sends until it sees a `^` character that signals that a new message begins. At this point it moves to the "in message" state, where it echoes back everything the client sends, incrementing each byte [[1]][10]. When the client sends a `$`, the server goes back to waiting for a new message. The `^` and `$` characters are only used to delimit messages - they are not echoed back.
|
||||
|
||||
An implicit arrow exists from each state back to the "wait for client" state, in case the client disconnects. By corollary, the only way for a client to signal "I'm done" is to simply close its side of the connection.
|
||||
|
||||
Obviously, this protocol is a simplification of more realistic protocols that have complicated headers, escape sequences (to support `$` inside a message body, for example) and additional state transitions, but for our goals this will do just fine.
|
||||
|
||||
Another note: this series is introductory, and assumes clients are generally well behaved (albeit potentially slow); therefore there are no timeouts and no special provisions made to ensure that the server doesn't end up being blocked indefinitely by rogue (or buggy) clients.
|
||||
|
||||
### A sequential server
|
||||
|
||||
Our first server in this series is a simple "sequential" server, written in C without using any libraries beyond standard POSIX fare for sockets. The server is sequential because it can only handle a single client at any given time; when a client connects, the server enters the state machine shown above and won't even listen on the socket for new clients until the current client is done. Obviously this isn't concurrent and doesn't scale beyond very light loads, but it's helpful to discuss since we need a simple-to-understand baseline.
|
||||
|
||||
The full code for this server [is here][11]; in what follows, I'll focus on some highlights. The outer loop in `main` listens on the socket for new clients to connect. Once a client connects, it calls `serve_connection` which runs through the protocol until the client disconnects.
|
||||
|
||||
To accept new connections, the sequential server calls `accept` on a listening socket in a loop:
|
||||
|
||||
```
|
||||
while (1) {
|
||||
struct sockaddr_in peer_addr;
|
||||
socklen_t peer_addr_len = sizeof(peer_addr);
|
||||
|
||||
int newsockfd =
|
||||
accept(sockfd, (struct sockaddr*)&peer_addr, &peer_addr_len);
|
||||
|
||||
if (newsockfd < 0) {
|
||||
perror_die("ERROR on accept");
|
||||
}
|
||||
|
||||
report_peer_connected(&peer_addr, peer_addr_len);
|
||||
serve_connection(newsockfd);
|
||||
printf("peer done\n");
|
||||
}
|
||||
```
|
||||
|
||||
Each time `accept` returns a new connected socket, the server calls `serve_connection`; note that this is a _blocking_ call - until `serve_connection` returns, `accept` is not called again; the server blocks until one client is done before accepting a new client. In other words, clients are serviced _sequentially_ .
|
||||
|
||||
Here's `serve_connection`:
|
||||
|
||||
```
|
||||
typedef enum { WAIT_FOR_MSG, IN_MSG } ProcessingState;
|
||||
|
||||
void serve_connection(int sockfd) {
|
||||
if (send(sockfd, "*", 1, 0) < 1) {
|
||||
perror_die("send");
|
||||
}
|
||||
|
||||
ProcessingState state = WAIT_FOR_MSG;
|
||||
|
||||
while (1) {
|
||||
uint8_t buf[1024];
|
||||
int len = recv(sockfd, buf, sizeof buf, 0);
|
||||
if (len < 0) {
|
||||
perror_die("recv");
|
||||
} else if (len == 0) {
|
||||
break;
|
||||
}
|
||||
|
||||
for (int i = 0; i < len; ++i) {
|
||||
switch (state) {
|
||||
case WAIT_FOR_MSG:
|
||||
if (buf[i] == '^') {
|
||||
state = IN_MSG;
|
||||
}
|
||||
break;
|
||||
case IN_MSG:
|
||||
if (buf[i] == '$') {
|
||||
state = WAIT_FOR_MSG;
|
||||
} else {
|
||||
buf[i] += 1;
|
||||
if (send(sockfd, &buf[i], 1, 0) < 1) {
|
||||
perror("send error");
|
||||
close(sockfd);
|
||||
return;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
close(sockfd);
|
||||
}
|
||||
```
|
||||
|
||||
It pretty much follows the protocol state machine. Each time around the loop, the server attempts to receive data from the client. Receiving 0 bytes means the client disconnected, and the loop exits. Otherwise, the received buffer is examined byte by byte, and each byte can potentially trigger a state change.
|
||||
|
||||
The number of bytes `recv` returns is completely independent of the number of messages (`^...$` enclosed sequences of bytes) the client sends. Therefore, it's important to go through the whole buffer in a state-keeping loop. Critically, each received buffer may contain multiple messages, but also the start of a new message without its actual ending; the ending can arrive in the next buffer, which is why the processing state is maintained across loop iterations.
|
||||
|
||||
For example, suppose the `recv` function in the main loop returned non-empty buffers three times for some connection:
|
||||
|
||||
1. `^abc$de^abte$f`
|
||||
|
||||
2. `xyz^123`
|
||||
|
||||
3. `25$^ab$abab`
|
||||
|
||||
What data is the server sending back? Tracing the code manually is very useful to understand the state transitions (for the answer see [[2]][12]).
|
||||
|
||||
### Multiple concurrent clients
|
||||
|
||||
What happens when multiple clients attempt to connect to the sequential server at roughly the same time?
|
||||
|
||||
The server's code (and its name - `sequential-server`) make it clear that clients are only handled _one at a time_ . As long as the server is busy dealing with a client in `serve_connection`, it doesn't accept new client connections. Only when the current client disconnects does `serve_connection` return and the outer-most loop may accept new client connections.
|
||||
|
||||
To show this in action, [the sample code for this series][13] includes a Python script that simulates several clients trying to connect at the same time. Each client sends the three buffers shown above [[3]][14], with some delays between them.
|
||||
|
||||
The client script runs the clients concurrently in separate threads. Here's a transcript of the client's interaction with our sequential server:
|
||||
|
||||
```
|
||||
$ python3.6 simple-client.py -n 3 localhost 9090
|
||||
INFO:2017-09-16 14:14:17,763:conn1 connected...
|
||||
INFO:2017-09-16 14:14:17,763:conn1 sending b'^abc$de^abte$f'
|
||||
INFO:2017-09-16 14:14:17,763:conn1 received b'b'
|
||||
INFO:2017-09-16 14:14:17,802:conn1 received b'cdbcuf'
|
||||
INFO:2017-09-16 14:14:18,764:conn1 sending b'xyz^123'
|
||||
INFO:2017-09-16 14:14:18,764:conn1 received b'234'
|
||||
INFO:2017-09-16 14:14:19,764:conn1 sending b'25$^ab0000$abab'
|
||||
INFO:2017-09-16 14:14:19,765:conn1 received b'36bc1111'
|
||||
INFO:2017-09-16 14:14:19,965:conn1 disconnecting
|
||||
INFO:2017-09-16 14:14:19,966:conn2 connected...
|
||||
INFO:2017-09-16 14:14:19,967:conn2 sending b'^abc$de^abte$f'
|
||||
INFO:2017-09-16 14:14:19,967:conn2 received b'b'
|
||||
INFO:2017-09-16 14:14:20,006:conn2 received b'cdbcuf'
|
||||
INFO:2017-09-16 14:14:20,968:conn2 sending b'xyz^123'
|
||||
INFO:2017-09-16 14:14:20,969:conn2 received b'234'
|
||||
INFO:2017-09-16 14:14:21,970:conn2 sending b'25$^ab0000$abab'
|
||||
INFO:2017-09-16 14:14:21,970:conn2 received b'36bc1111'
|
||||
INFO:2017-09-16 14:14:22,171:conn2 disconnecting
|
||||
INFO:2017-09-16 14:14:22,171:conn0 connected...
|
||||
INFO:2017-09-16 14:14:22,172:conn0 sending b'^abc$de^abte$f'
|
||||
INFO:2017-09-16 14:14:22,172:conn0 received b'b'
|
||||
INFO:2017-09-16 14:14:22,210:conn0 received b'cdbcuf'
|
||||
INFO:2017-09-16 14:14:23,173:conn0 sending b'xyz^123'
|
||||
INFO:2017-09-16 14:14:23,174:conn0 received b'234'
|
||||
INFO:2017-09-16 14:14:24,175:conn0 sending b'25$^ab0000$abab'
|
||||
INFO:2017-09-16 14:14:24,176:conn0 received b'36bc1111'
|
||||
INFO:2017-09-16 14:14:24,376:conn0 disconnecting
|
||||
```
|
||||
|
||||
The thing to note here is the connection name: `conn1` managed to get through to the server first, and interacted with it for a while. The next connection - `conn2` - only got through after the first one disconnected, and so on for the third connection. As the logs show, each connection is keeping the server busy for ~2.2 seconds (which is exactly what the artificial delays in the client code add up to), and during this time no other client can connect.
|
||||
|
||||
Clearly, this is not a scalable strategy. In our case, the client incurs the delay leaving the server completely idle for most of the interaction. A smarter server could handle dozens of other clients while the original one is busy on its end (and we'll see how to achieve that later in the series). Even if the delay is on the server side, this delay is often something that doesn't really keep the CPU too busy; for example, looking up information in a database (which is mostly network waiting time for a database server, or disk lookup time for local databases).
|
||||
|
||||
### Summary and next steps
|
||||
|
||||
The goal of presenting this simple sequential server is twofold:
|
||||
|
||||
1. Introduce the problem domain and some basics of socket programming used throughout the series.
|
||||
|
||||
2. Provide motivation for concurrent serving - as the previous section demonstrates, the sequential server doesn't scale beyond very trivial loads and is not an efficient way of using resources, in general.
|
||||
|
||||
Before reading the next posts in the series, make sure you understand the server/client protocol described here and the code for the sequential server. I've written about such simple protocols before; for example,[framing in serial communications][15] and [co-routines as alternatives to state machines][16]. For basics of network programming with sockets, [Beej's guide][17] is not a bad starting point, but for a deeper understanding I'd recommend a book.
|
||||
|
||||
If anything remains unclear, please let me know in comments or by email. On to concurrent servers!
|
||||
|
||||
* * *
|
||||
|
||||
|
||||
[[1]][1] The In/Out notation on state transitions denotes a [Mealy machine][2].
|
||||
|
||||
[[2]][3] The answer is `bcdbcuf23436bc`.
|
||||
|
||||
[[3]][4] With a small difference of an added string of `0000` at the end - the server's answer to this sequence is a signal for the client to disconnect; it's a simplistic handshake that ensures the client had time to receive all of the server's reply.
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
via: https://eli.thegreenplace.net/2017/concurrent-servers-part-1-introduction/
|
||||
|
||||
作者：[Eli Bendersky][a]
|
||||
译者：[译者ID](https://github.com/译者ID)
|
||||
校对：[校对者ID](https://github.com/校对者ID)
|
||||
|
||||
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||||
|
||||
[a]:https://eli.thegreenplace.net/pages/about
|
||||
[1]:https://eli.thegreenplace.net/2017/concurrent-servers-part-1-introduction/#id1
|
||||
[2]:https://en.wikipedia.org/wiki/Mealy_machine
|
||||
[3]:https://eli.thegreenplace.net/2017/concurrent-servers-part-1-introduction/#id2
|
||||
[4]:https://eli.thegreenplace.net/2017/concurrent-servers-part-1-introduction/#id3
|
||||
[5]:https://eli.thegreenplace.net/tag/concurrency
|
||||
[6]:https://eli.thegreenplace.net/tag/c-c
|
||||
[7]:http://eli.thegreenplace.net/2017/concurrent-servers-part-1-introduction/
|
||||
[8]:http://eli.thegreenplace.net/2017/concurrent-servers-part-2-threads/
|
||||
[9]:http://eli.thegreenplace.net/2017/concurrent-servers-part-3-event-driven/
|
||||
[10]:https://eli.thegreenplace.net/2017/concurrent-servers-part-1-introduction/#id4
|
||||
[11]:https://github.com/eliben/code-for-blog/blob/master/2017/async-socket-server/sequential-server.c
|
||||
[12]:https://eli.thegreenplace.net/2017/concurrent-servers-part-1-introduction/#id5
|
||||
[13]:https://github.com/eliben/code-for-blog/tree/master/2017/async-socket-server
|
||||
[14]:https://eli.thegreenplace.net/2017/concurrent-servers-part-1-introduction/#id6
|
||||
[15]:http://eli.thegreenplace.net/2009/08/12/framing-in-serial-communications/
|
||||
[16]:http://eli.thegreenplace.net/2009/08/29/co-routines-as-an-alternative-to-state-machines
|
||||
[17]:http://beej.us/guide/bgnet/
|
||||
[18]:https://eli.thegreenplace.net/2017/concurrent-servers-part-1-introduction/
|
||||
@ -0,0 +1,94 @@
|
||||
Q. Why's Oracle so two-faced over open source? A. Moolah, wonga, dosh
|
||||
============================================================
|
||||
|
||||
### And lobbying US government against it is NOT modernising IT
|
||||
|
||||
|
||||
|
||||
Oracle loves open source. Except when the database giant hates open source. Which, according to its recent lobbying of the US federal government, seems to be "most of the time".
|
||||
|
||||
Yes, Oracle has recently joined the Cloud Native Computing Foundation (CNCF) to up its support for open-source Kubernetes and, yes, it has long supported (and contributed to) Linux. And, yes, Oracle has even gone so far as to (finally) open up Java development by putting it under a foundation's stewardship.
|
||||
|
||||
Yet this same, seemingly open Oracle has actively hammered the US government to consider that "there is no math that can justify open source from a cost perspective as the cost of support plus the opportunity cost of forgoing features, functions, automation and security overwhelm any presumed cost savings."
|
||||
|
||||
That punch to the face was delivered in a letter to Christopher Liddell, a former Microsoft CFO and now director of Trump's American Technology Council, by Kenneth Glueck, Oracle senior vice president.
|
||||
|
||||
The US government had courted input on its IT modernisation programme. Others writing back to Liddell included AT&T, Cisco, Microsoft and VMware.
|
||||
|
||||
In other words, based on its letter, what Oracle wants us to believe is that open source leads to greater costs and poorly secured, limply featured software. Nor is Oracle content to leave it there, also arguing that open source is exactly how the private sector does _not_ function, seemingly forgetting that most of the leading infrastructure, big data, and mobile software today is open source.
|
||||
|
||||
Details!
|
||||
|
||||
Rather than take this counterproductive detour into self-serving silliness, Oracle would do better to follow Microsoft's path. Microsoft, too, used to Janus-face its way through open source, simultaneously supporting and bashing it. Only under chief executive Satya Nadella's reign did Microsoft realise it's OK to fully embrace open source, and its financial results have loved the commitment. Oracle has much to learn, and emulate, in Microsoft's approach.
|
||||
|
||||
### I love you, you're perfect. Now change
|
||||
|
||||
Oracle has never been particularly warm and fuzzy about open source. As founder Larry Ellison might put it, Oracle is a profit-seeking corporation, not a peace-loving charity. To the extent that Oracle embraces open source, therefore it does so for financial reward, just like every other corporation.
|
||||
|
||||
Few, however, are as blunt as Oracle about this fact of corporate open-source life. As Ellison told the _Financial Times_ back in 2006: "If an open-source product gets good enough, we'll simply take it. So the great thing about open source is nobody owns it – a company like Oracle is free to take it for nothing, include it in our products and charge for support, and that's what we'll do.
|
||||
|
||||
"So it is not disruptive at all – you have to find places to add value. Once open source gets good enough, competing with it would be insane... We don't have to fight open source, we have to exploit open source."
|
||||
|
||||
"Exploit" sounds about right. While Oracle doesn't crack the top-10 corporate contributors to the Linux kernel, it does register a respectable number 12, which helps it influence the platform enough to feel comfortable building its IaaS offering on Linux (and Xen for virtualisation). Oracle has also managed to continue growing MySQL's clout in the industry while improving it as a product and business. As for Kubernetes, Oracle's decision to join the CNCF also came with P&L strings attached. "CNCF technologies such as Kubernetes, Prometheus, gRPC and OpenTracing are critical parts of both our own and our customers' development toolchains," [said Mark Cavage][3], vice president of software development at Oracle.
|
||||
|
||||
One can argue that Oracle has figured out the exploitation angle reasonably well.
|
||||
|
||||
This, however, refers to the right kind of exploitation, the kind that even free software activist Richard Stallman can love (or, at least, tolerate). But when it comes to government lobbying, Oracle looks a lot more like Mr Hyde than Dr Jekyll.
|
||||
|
||||
### Lies, damned lies, and Oracle lobbying
|
||||
|
||||
The current US president has many problems (OK, _many, many_ problems), but his decision to follow the Obama administration's support for IT modernisation is commendable. Most recently, the Trump White House asked for [feedback][4] on how best to continue improving government IT. Oracle's [response][5] is high comedy in many respects.
|
||||
|
||||
As TechDirt's Mike Masnick [summarises][6], Oracle's "latest crusade is against open-source technology being used by the federal government – and against the government hiring people out of Silicon Valley to help create more modern systems. Instead, Oracle would apparently prefer the government just give it lots of money." Oracle is very good at making lots of money. As such, its request for even more isn't too surprising.
|
||||
|
||||
What is surprising is the brazenness of its position. As Masnick opines: "The sheer contempt found in Oracle's submission on IT modernization is pretty stunning." Why? Because Oracle contradicts much that it publicly states in other forums about open source and innovation. More than this, Oracle contradicts much of what we now know is essential to competitive differentiation in an increasingly software and data-driven world.
|
||||
|
||||
Take, for example, Oracle's contention that "significant IT development expertise is not... central to successful modernization efforts".
|
||||
|
||||
What? In our "software is eating the world" existence Oracle clearly believes that CIOs are buyers, not doers: "The most important skill set of CIOs today is to critically compete and evaluate commercial alternatives to capture the benefits of innovation conducted at scale, and then to manage the implementation of those technologies efficiently."
|
||||
|
||||
While there is some truth to Oracle's claim – every project shouldn't be a custom one-off that must be supported forever – it's crazy to think that a CIO – government or otherwise – is doing their job effectively by simply shovelling cash into vendors' bank accounts.
|
||||
|
||||
Indeed, as Masnick points out: "If it weren't for Oracle's failures, there might not even be a USDS [the US Digital Service created in 2014 to modernise federal IT]. USDS really grew out of the emergency hiring of some top-notch internet engineers in response to the Healthcare.gov rollout debacle. And if you don't recall, a big part of that debacle was blamed on Oracle's technology."
|
||||
|
||||
In short, [blindly giving money to Oracle][7] and other big vendors is the opposite of IT modernisation.
|
||||
|
||||
In its letter to Liddell, Oracle proceeded to make the fantastic (by which I mean "silly and false") claim that "the fact is that the use of open-source software has been declining rapidly in the private sector". What?!? This is so incredibly untrue that Oracle should score points for being willing to say it out loud. Take a stroll through the most prominent software in big data (Hadoop, Spark, Kafka, etc.), mobile (Android), application development (Kubernetes, Docker), machine learning/AI (TensorFlow, MxNet), and compare it to Oracle's statement. One conclusion must be that Oracle believes its CIO audience is incredibly stupid.
|
||||
|
||||
Oracle then tells a half-truth by declaring: "There is no math that can justify open source from a cost perspective." How so? Because "the cost of support plus the opportunity cost of forgoing features, functions, automation and security overwhelm any presumed cost savings." Which I guess is why Oracle doesn't use any open source like Linux, Kubernetes, etc. in its services.
|
||||
|
||||
Oops.
|
||||
|
||||
### The Vendor Formerly Known As Satan
|
||||
|
||||
The thing is, Oracle doesn't need to do this and, for its own good, shouldn't do this. After all, we already know how this plays out. We need only look at what happened with Microsoft.
|
||||
|
||||
Remember when Microsoft wanted us to "[get the facts][8]" about Linux? Now it's a big-time contributor to Linux. Remember when it told us open source was anti-American and a cancer? Now it aggressively contributes to a huge variety of open-source projects, some of them homegrown in Redmond, and tells the world that "Microsoft [loves][9] open source." Of course, Microsoft loves open source for the same reason any corporation does: it drives revenue as developers look to build applications filled with open-source components on Azure. There's nothing wrong with that.
|
||||
|
||||
Would Microsoft prefer government IT to purchase SQL Server instead of open-source-licensed PostgreSQL? Sure. But look for a [single line][10] in its response to the Trump executive order that signals "open source is bad". You won't find it. Why? Because Microsoft understands that open source is a friend, not foe, and has learned how to monetise it.
|
||||
|
||||
Microsoft, in short, is no longer conflicted about open source. It can compete at the product level while embracing open source at the project level, which helps fuel its overall product and business strategy. Oracle isn't there yet, and is still stuck where Microsoft was a decade ago.
|
||||
|
||||
It's time to grow up, Oracle. For a company that builds great software and understands that it increasingly needs to depend on open source to build that software, it's disingenuous at best to lobby the US government to put the freeze on open source. Oracle needs to learn from Microsoft, stop worrying and love the open-source bomb. It was a key ingredient in Microsoft's resurgence. Maybe it could help Oracle get a cloud clue, too.
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
via: https://www.theregister.co.uk/2017/10/12/oracle_must_grow_up_on_open_source/
|
||||
|
||||
作者：[ Matt Asay ][a]
|
||||
译者：[译者ID](https://github.com/译者ID)
|
||||
校对：[校对者ID](https://github.com/校对者ID)
|
||||
|
||||
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||||
|
||||
[a]:https://www.theregister.co.uk/Author/2905
|
||||
[1]:https://www.theregister.co.uk/Author/2905
|
||||
[2]:https://forums.theregister.co.uk/forum/1/2017/10/12/oracle_must_grow_up_on_open_source/
|
||||
[3]:https://www.oracle.com/corporate/pressrelease/oracle-joins-cncf-091317.html
|
||||
[4]:https://www.whitehouse.gov/the-press-office/2017/05/11/presidential-executive-order-strengthening-cybersecurity-federal
|
||||
[5]:https://github.com/GSA/modernization/issues/41
|
||||
[6]:https://www.techdirt.com/articles/20170930/00522238319/oracle-tells-white-house-stop-hiring-silicon-valley-people-ditch-open-source.shtml
|
||||
[7]:http://www.nytimes.com/2013/12/01/us/politics/inside-the-race-to-rescue-a-health-site-and-obama.html?pagewanted=all
|
||||
[8]:http://www.zdnet.com/article/microsoft-kills-its-get-the-facts-anti-linux-site/
|
||||
[9]:https://channel9.msdn.com/Events/Ignite/2016/BRK2158
|
||||
[10]:https://github.com/GSA/modernization/issues/98
|
||||
@ -1,86 +0,0 @@
|
||||
五步的计划促使项目团队作出改变
|
||||
============================================================
|
||||
|
||||
|
||||
Image by : opensource.com
|
||||
|
||||
组建任何团队目的都是首要之事。如果一人足以实现那个目的，那么就没有必要组成团队。而且如果没有重要目标，你根本不需要一个团队。但只要任务需要的专业知识比一个人所拥有的更多，遇到集体参与的问题——如果处理不当，会使你脱离正轨。
|
||||
|
||||
想象一群人困在洞穴中。没有一个人具备如何出去的全部知识，所以每个人要协作，心路常开，在别人想要做什么事的时候尽力配合。当（且仅当）集中了适当的工作组（译者os：这里怪怪的？？？）才能产生合适的环境来实现共同的目标。
|
||||
|
||||
但确实有人觉得待在洞穴中很舒适而且只想待在那。在组织里，领导者们如何掌握实际上抵触改善、待在洞穴中觉得舒适的人？同时该如何找到拥有共同目标但是不在自己组织的人？
|
||||
|
||||
我从事指导国际销售培训，刚开始甚至很少有人认为我的工作有价值。所以，我想出一套使他们信服的战术。那个战术非常成功以至于我决定深入研究它并与各位[分享][2]。
|
||||
|
||||
### 获得支持
|
||||
|
||||
为了建立公司强大的企业文化，有人会反对改变并且，从幕后，打压任何改变的提议。他们希望每个人都待在那个舒适的洞穴里。例如，当我第一次接触到海外销售培训，我受到了一些关键人物的严厉阻挠。他们迫使其他人相信在东京的人不会提供销售培训——只要基本的产品培训就会成功。
|
||||
|
||||
尽管我最终解决了这个问题，但我这时候真的不知道该怎么办。所以，我开始研究顾问在改变公司里抗拒改变的人的想法这个问题上该如何给出建议。从学者[Laurence Haughton][3]的研究中，我发现一般对于改变的提议，组织中83%的人最开始不会支持你。大约17% _会_从一开始就支持你，但是只要看到一个实验案例成功之后，他们觉得这个主意安全可行了，60%的人会支持你。最后，有部分人会反对任何改变，无论它有多棒。
|
||||
|
||||
我研究的步骤：
|
||||
|
||||
* 从试验项目开始
|
||||
* 开导 CAVE people
|
||||
* 快速跟进
|
||||
* 开导 CAVE bosses
|
||||
* 全局展开
|
||||
(译者注：CAVE, Citizens Against Virtually Everything，反对任何事物的人，作者在后文提到）
|
||||
|
||||
### 1\. 从试验项目开始
|
||||
|
||||
找到价值和成功率均高的项目——不是大的、成本高的、周期长的、全局的行动。然后，找到能看到项目价值、理解它的价值并能为之奋斗的关键人物。这些人不应该只是“好人”或者“朋友”;他们必须相信项目的目标而且拥有推进项目的能力/经验。不要急于求成。只要足够支持你研究并保持进度即可。
|
||||
|
||||
个人而言，我在新加坡的一个小型车辆代理商那里举办了自己的第一场销售研讨会。虽然并不是特别成功,但足以让人们开始讨论销售训练会达到怎样的效果。那时候的我困在洞穴里（一份我不想做的工作）。这个试验销售训练是我走出困境的蓝图。
|
||||
|
||||
### 2\. 开导 CAVE people
|
||||
|
||||
CAVE 实际上是我从 Laurence Haughton 那里听来的缩略词。它代表着 Citizens Against Virtually Everything.
|
||||
|
||||
你得辨别这些人，因为他们会暗地里阻挠项目的进展，特别是早期脆弱的时候。他们容易黑化：总是消极。他们频繁使用“但是，”“如果，”和“为什么，”，只是想推脱你。他们询问轻易不可得的细节信息。他们花费过多的时间在问题上，而不是寻找解决方案。他们认为每个失败都是趋势的开始。他们总是针对别人而不是研究问题。他们作出反对建议的陈述却又不能轻易确保。
|
||||
|
||||
避开 CAVE people;不要让他们太早加入项目的讨论。他们固守成见，因为他们看不到改变所具有的价值。他们安居于洞穴。所以试着让他们去做些其他事。你应该找出我上面提到那17%的人群中的关键人物，那些想要改变的人，并且跟他们开一个非常隐秘的准备会。
|
||||
|
||||
我在五十铃汽车（股东之一是通用汽车公司）的时候，销售训练项目开始于一个销往世界上其他小国家的合资发行公司，主要是非洲，南亚，拉丁美洲和中东。我的个人团队由通用汽车公司雪佛兰的人、五十铃产品经理和分公司的销售计划员工组成。隔绝其他任何人于这个圈子之外。
|
||||
|
||||
### 3\. 快速跟进
|
||||
|
||||
CAVE people 总是慢吞吞的，那么迅速行动起来。如果你在他们参与之前就有了小成就的经历，他们对你团队产生消极影响的能力将大大减弱——如果你预知他们不可避免的拒绝先于他们表述出来。再一次，选择一个成功率高的试验项目，很快能出结果的。然后宣传成功，就像广告上的加粗标题。
|
||||
|
||||
一旦我在新加坡研讨会上所言开始流传，其他地区开始意识到销售训练的好处。仅在新加坡研讨会之后，我就被派到马来西亚开展四次以上。
|
||||
|
||||
### 4\. 开导 CAVE bosses
|
||||
|
||||
只要你取得了第一个小项目的成功，针对能影响 CAVE 首领的关键人物推荐项目。让团队继续项目以告诉关键人物成功的经历。一线人员甚至顾客也能提供有力的证明。 CAVE 管理者往往只着眼于销量和收益，那么就宣扬项目在降低开支、减少浪费和增加销量方面的价值。
|
||||
|
||||
自新加坡的第一次研讨会及之后，我向直接掌握了五十铃销售渠道的前线销售部门员工和通用汽车真正想看到进展的人极力宣传他们的成功。当他们接受了之后，他们会向上级提出培训请求并让其看到分公司销量的提升。
|
||||
|
||||
### 5\. 全局展开
|
||||
|
||||
一旦一把手站在了自己这边，立马向整个组织宣告成功的试验项目。讨论项目的扩展。
|
||||
|
||||
用上面的方法，在21年的职业生涯中，我在世界各地超过60个国家举办了研讨会。即我确实出了洞穴——并且真的看到了广阔的世界。
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
作者简介：
|
||||
|
||||
Ron McFarland - Ron McFarland 已在日本工作40年，从事国际销售、销售管理和在世界范围内扩展销售业务30载有余。他曾去或就职于80多个国家。在过去的14年里， Ron 为总部位于东京的日本硬件切割厂在美国和欧洲各地建立分销商。
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
via: https://opensource.com/open-organization/17/1/escape-the-cave
|
||||
|
||||
作者：[Ron McFarland][a]
|
||||
译者：[XYenChi](https://github.com/XYenChi)
|
||||
校对：[校对者ID](https://github.com/校对者ID)
|
||||
|
||||
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||||
|
||||
[a]:https://opensource.com/users/ron-mcfarland
|
||||
[1]:https://opensource.com/open-organization/17/1/escape-the-cave?rate=dBJIKVJy720uFj0PCfa1JXDZKkMwozxV8TB2qJnoghM
|
||||
[2]:http://www.slideshare.net/RonMcFarland1/creating-change-58994683
|
||||
[3]:http://www.laurencehaughton.com/
|
||||
[4]:https://opensource.com/user/68021/feed
|
||||
[5]:https://opensource.com/open-organization/17/1/escape-the-cave#comments
|
||||
[6]:https://opensource.com/users/ron-mcfarland
|
||||
@ -1,95 +0,0 @@
|
||||
LEDE 和 OpenWrt
|
||||
===================
|
||||
|
||||
[OpenWrt][1] 项目可能是最广为人知的 Linux 发行版，对于家用 WiFi 路由器和接入点； 12 年多以前，它产自现在有名的 Linksys WRT54G 路由器的源代码。五月初，OpenWrt 用户社区陷入一片巨大的混乱中，当一群 OpenWrt 代码开发者 [宣布][2] 他们将开始着手 OpenWrt 的一个副产品 （或，可能，一个分支）叫 [Linux 嵌入开发环境][3] (LEDE)时。为什么产生分裂对公众来说并不明朗，而且 LEDE 宣言惊到了一些其他 OpenWrt 开发者也暗示这团队的内部矛盾。
|
||||
|
||||
LEDE 宣言被 Jo-Philipp Wich 于五月三日发往所有 OpenWrt 开发者列表和新 LEDE 开发者列表。它描述 LEDE 为"OpenWrt 社区的一次重启" 和 "OpenWrt 项目的一个副产品" 希望产生一个 Linux 嵌入式开发社区 "注重透明性、合作和权利分散。"
|
||||
|
||||
给出的重启的原因是 OpenWrt 遭受着长期以来存在且不能从内部解决的问题——换句话说，关于内部处理方式和政策。例如，宣言称，开发者的数目在不断减少，却没有接纳新开发者的方式（而且貌似没有授权委托访问给新开发者的方法）。项目架构不可靠（例如，这么多年来服务器挂掉在这个项目中也引发了相当多的矛盾），宣言说到，但是内部不合和单点错误阻止了修复它。内部和从这个项目到外面世界也存在着"交流、透明度和合作"的普遍缺失。最后，一些技术缺陷被引用：不充分的测试、缺乏常规维护,和窘迫的稳固性与文档。
|
||||
|
||||
该宣言继续描述 LEDE 重启将解决这些问题。所有交流频道都会打开供公众使用，决策将在项目范围内投票决出，合并政策将放宽等等。更详细的说明可以在 LEDE 站点的 [rules][4] 页找到。其他特别之处中,它说将贡献者将只有一个阶级（也就是，没有“代码开发者”这样拥有额外权利的群体），简单的少数服从多数投票作出决定，并且任何被这个项目管理的架构必须有三个以上管理员账户。在 LEDE 邮件列表， Hauke Mehrtens [补充][5] 到项目将会努力修补发送上游消息——过去 OpenWrt 被批判的一点，尤其是有关内核。
|
||||
|
||||
除了 Wich，这个宣言被 OpenWrt 贡献者 John Crispin、 Daniel Golle、 Felix Fietkau、 Mehrtens、 Matthias Schiffer 和 Steven Barth 共同创作。以给其他有兴趣参与的人访问 LEDE 站点的邀请为结尾。
|
||||
|
||||
#### 回应和问题
|
||||
|
||||
有人可能会猜想 LEDE 组织者预期他们的宣言会有或积极或消极的反响。毕竟，细读宣言中批判 OpenWrt 项目暗示了有一些 OpenWrt 项目成员 LEDE 阵营发现难以共事（“单点错误” 或 “内部不和”阻止了架构修复，例如）
|
||||
|
||||
并且，确实，有很多消极回应。创立者之一 Mike Baker [回应][6] 了一些警告，反驳所有 LEDE 宣言中的结论并称“短语像‘重启’都是含糊不清且具有误导性的而且 LEDE 项目定义它的真实本质失败了。”与此同时，有人关闭了那些在 LEDE 上署名的开发者在 @openwrt.org 的邮件入口;当 Fietkau [提出反对][7], Baker [回复][8]账户“暂时停用”因为“还不确定 LEDE 代表 OpenWrt。” Imre Kaloz, 另一个 OpenWrt 核心成员，[写][9]到“ LEDE 团队生出了大多数 [破] 事儿”在 OpenWrt 里这就是现在所抱怨的。
|
||||
|
||||
但是大多数 OpenWrt 列表的回应对该宣言表示疑惑。列表成员不明确 LEDE 团队是否将为 OpenWrt [继续贡献][10],或导致了这个分支的机构的[确切本质][11]和内部问题是什么。 Baker的第一反应是后悔在宣言中引用的那些问题缺乏公开讨论：“我们意识到当前的 OpenWrt 项目遭受着许多的问题，”但“我们希望有机会去讨论并尝试着解决”它们。 Baker 作出结论：
|
||||
|
||||
我们强调我们确实希望有一个公开的讨论和解决即将到来的事情。我们的目标是与所有能够且希望对 OpenWrt 作出贡献的参与者共事，包括 LEDE 团队。
|
||||
|
||||
除了有关新项目的初心的问题之外，一些列表贡献者提出 LEDE 是否与 OpenWrt 有相同的使用场景定位，给新项目取一个听起来更一般的名字的疑惑。此外，许多人，像 Roman Yeryomin，[表示疑惑][12]为什么这些问题需要 LEDE 团队的离开（来解决），特别是，与此同时， LEDE 团队由大部分活跃核心 OpenWrt 开发者构成。一些列表贡献者，像 Michael Richardson，甚至不清楚[谁还会开发][13] OpenWrt。
|
||||
|
||||
#### 澄清
|
||||
|
||||
LEDE 团队尝试着深入阐释他们的境况。在 Fietkau 给 Baker 的回复中，他说在 OpenWrt 内部关于有目的地改变的讨论会很快变得“有毒，”因此导致没有进展。而且：
|
||||
|
||||
这些讨论的要点在于那些掌握着框架关键部分的人精力有限却拒绝他人的加入和帮助，甚至是面对无法及时解决的重要问题时。
|
||||
|
||||
这种像单点错误一样的事已经持续了很多年了，没有任何有意义的进展来解决它。
|
||||
|
||||
Wich 和 Fietkau 都没有明显指出特别的个体，虽然其他在列表的人可能会想这个基础建设和内部讨论——在 OpenWrt 找出问题针对某些人。 Daniel Dickinson [陈述][14]到：
|
||||
|
||||
我的印象是 Kaloz (至少) 以基础建设为胁来保持控制，并且基本问题是 OpenWrt 是*不*民主的，而且忽视那些真正在 openwrt 工作的人想要的是什么无视他们的愿望，因为他/他们把握着要害。
|
||||
|
||||
另一方面， Luka Perkov [指出][15] 很多 OpemWrt 开发者想从 Subversion 转移到 Git，但 Fietkau 负责块修改。
|
||||
|
||||
清晰的是 OpenWrt 的管理结构并非如预期应用，结果导致，个人冲突爆发而且能够自立门户或者块有预谋地变更，因为没有规定好的程序。明显，这不是一个能长期持续的模式。
|
||||
|
||||
五月6日, Crispin 以新思路[写给][16] OpenWrt 列表成员，尝试着重构 LEDE 项目宣言。这不是，他说，意味着“敌对或分裂”行为，只是与性能不良的 OpenWrt 结构做个清晰的划分并以新的方式开始。问题在于“不要局限于一次单独的时间，一个人或者一次口水战，”他说。“我们想与过去自己造成的错误和作出过很多次的错误管理决定分开” Crispin 也承认宣言没有把握好，说 LEDE 团队 “弄糟了开始的政纲。”
|
||||
|
||||
Crispin 的邮件似乎没能使 Kaloz 满意, 她[坚持认为][17] Crispin （作为发行经理）和 Fietkau （作为领头开发者）可以轻易地在 OpenWrt 内部作出想要的改变。 但是讨论的线索后来变得沉寂;之后 LEDE 或者 OpenWrt 哪边会发生什么还有待观察。
|
||||
|
||||
#### 目的
|
||||
|
||||
对于那些仍在寻找 LEDE 认为有问题的事情更多的细节的 OpenWrt 成员，有更多的信息来源可以为这个问题提供线索。在公众宣言之前，LEDE 组织花了几周谈论他们的计划，会议的 IRC 日志现已[推出][18]。特别有趣的是3月30日[会议][19]，包含了这个项目目标的细节讨论。
|
||||
|
||||
有些关于 OpenWrt 的架构特定的抱怨包含在内，像项目的 Trac issue 追踪者的缺点。它充斥着不完整的漏洞报告和“我也是”评论， Wich 说，结果，几乎没有贡献者使用它。此外，人们对这件事感到困惑，漏洞在 Github 上也正被追踪，使得问题应该在哪里被讨论不明了。
|
||||
|
||||
IRC 讨论也定下了开发流程本身。LEDE 团队想作出些改变，以合并到主干的 staging trees 的使用为开端，与 OpenWrt 使用的 commit-directly-to-master 方式不同。项目也将提供基于时间的发行版并鼓励用户测试通过只发行已被成功测试的二进制模块，由社区而不是核心开发者，在实际的硬件上。
|
||||
|
||||
最后，IRC 讨论确定了 LEDE 团队的目的不是用它的宣言吓唬 OpenWrt 。 Crispin 提到 LEDE 首先是“半公开的”并渐渐做得更公开。 Wich 解释说他希望 LEDE 是“中立的、专业的并打开大门欢迎 OpenWrt 以便将来的合并”不幸的是，前期发起并不是做得很好。
|
||||
|
||||
在邮件中， Fietkau 补充道核心 OpenWrt 开发者确实在任务中遇到了像补丁复审和维护这些让他们完成不了其他工作——比如配置下载镜像和改良架构系统的瓶颈。在 LEDE 宣言之后短短几天内，他说，团队成功解决了镜像和建设系统任务，而这些已被搁置多年。
|
||||
|
||||
很多我们在 LEDE 所做是基于移动到 Github 分散包的开发和放开包应如何被维护的控制的经验。这样最终有效减少了我们的工作量而且我们有了很多更活跃的开发者。
|
||||
|
||||
我们真的希望为核心开发做一些类似的事，但是根据我们想作出更大改变的经验，我们觉得在 OpenWrt 项目内做不到。
|
||||
|
||||
修复架构也将收获其他好处，他说，就比如为管理用于同意发行的密码。团队正在考虑附加一些没有上游补丁的情况，像需要补丁的描述和为什么没有发送到上游的解释。他也提到很多留下的 OpenWrt 开发者表示有兴趣加入 LEDE，相关当事人正试图弄清楚他们是否会重新合并项目。
|
||||
|
||||
有人希望 LEDE 更为干脆的管理模式和更为透明的分工会在 OpenWrt 困扰的方面取得成功。解决最初的宣言中诟病的沟通方面的问题会是最大的障碍。如果那个过程处理得好，那么，未来 LEDE 和 OpenWrt 可能找到共同之处并协作。否则，之后两个团队可能一起被逼到拥有比以前更少资源，这是开发者或用户不想看到的。
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
via: https://lwn.net/Articles/686767/
|
||||
|
||||
作者：[Nathan Willis ][a]
|
||||
译者：[XYenChi](https://github.com/XYenChi)
|
||||
校对：[校对者ID](https://github.com/校对者ID)
|
||||
|
||||
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||||
|
||||
[a]:https://lwn.net/Articles/686767/
|
||||
[1]:https://openwrt.org/
|
||||
[2]:https://lwn.net/Articles/686180/
|
||||
[3]:https://www.lede-project.org/
|
||||
[4]:https://www.lede-project.org/rules.html
|
||||
[5]:http://lists.infradead.org/pipermail/lede-dev/2016-May/000080.html
|
||||
[6]:https://lwn.net/Articles/686988/
|
||||
[7]:https://lwn.net/Articles/686989/
|
||||
[8]:https://lwn.net/Articles/686990/
|
||||
[9]:https://lwn.net/Articles/686991/
|
||||
[10]:https://lwn.net/Articles/686995/
|
||||
[11]:https://lwn.net/Articles/686996/
|
||||
[12]:https://lwn.net/Articles/686992/
|
||||
[13]:https://lwn.net/Articles/686993/
|
||||
[14]:https://lwn.net/Articles/686998/
|
||||
[15]:https://lwn.net/Articles/687001/
|
||||
[16]:https://lwn.net/Articles/687003/
|
||||
[17]:https://lwn.net/Articles/687004/
|
||||
[18]:http://meetings.lede-project.org/lede-adm/2016/?C=M;O=A
|
||||
[19]:http://meetings.lede-project.org/lede-adm/2016/lede-adm.2016-03-30-11.05.log.html
|
||||
@ -0,0 +1,214 @@
|
||||
[并发服务器： 第一节 —— 简介][18]
|
||||
============================================================
|
||||
|
||||
这是关于并发网络服务器编程的第一篇教程。我计划测试几个主流的、可以同时处理多个客户端请求的服务器并发模型，基于可扩展性和易实现性对这些模型进行评判。所有的服务器都会监听套接字连接，并且实现一些简单的协议用于与客户端进行通讯。
|
||||
|
||||
该系列的所有文章：
|
||||
|
||||
* [第一节 - 简介][7]
|
||||
|
||||
* [第二节 - 线程][8]
|
||||
|
||||
* [第三节 - 事件驱动][9]
|
||||
|
||||
### 协议
|
||||
|
||||
该系列教程所用的协议都非常简单，但足以展示并发服务器设计的许多有趣层面。而且这个协议是 _有状态的_ —— 服务器根据客户端发送的数据改变内部状态，然后根据内部状态产生相应的行为。并非所有的协议都是有状态的 —— 实际上，基于 HTTP 的许多协议是无状态的，但是有状态的协议对于保证重要会议的可靠很常见。
|
||||
|
||||
在服务器端看来，这个协议的视图是这样的：
|
||||
|
||||
|
||||
|
||||
总之：服务器等待新客户端的连接；当一个客户端连接的时候，服务器会向该客户端发送一个 `*` 字符，进入“等待消息”的状态。在该状态下，服务器会忽略客户端发送的所有字符，除非它看到了一个 `^` 字符，这表示一个新消息的开始。这个时候服务器就会转变为“正在通信”的状态，这时它会向客户端回送数据，把收到的所有字符的每个字节加 1 回送给客户端 [ [1][10] ]。当客户端发送了 `$`字符，服务器就会退回到等待新消息的状态。`^` 和 `$` 字符仅仅用于分隔消息 —— 它们不会被服务器回送。
|
||||
|
||||
每个状态之后都有个隐藏的箭头指向 “等待客户端” 状态，用来防止客户端断开连接。因此，客户端要表示“我已经结束”的方法很简单，关掉它那一端的连接就好。
|
||||
|
||||
显然，这个协议是真实协议的简化版，真实使用的协议一般包含复杂的报文头，转义字符序列（例如让消息体中可以出现 `$` 符号），额外的状态变化。但是我们这个协议足以完成期望。
|
||||
|
||||
另一点：这个系列是引导性的，并假设客户端都工作的很好（虽然可能运行很慢）；因此没有设置超时，也没有设置特殊的规则来确保服务器不会因为客户端的恶意行为（或是故障）而出现阻塞，导致不能正常结束。
|
||||
|
||||
### 有序服务器
|
||||
|
||||
这个系列中我们的第一个服务端程序是一个简单的“有序”服务器，用 C 进行编写，除了标准的 POSIX 中用于套接字的内容以外没有使用其它库。服务器程序是有序的，因为它一次只能处理一个客户端的请求；当有客户端连接时，像之前所说的那样，服务器会进入到状态机中，并且不再监听套接字接受新的客户端连接，直到当前的客户端结束连接。显然这不是并发的，而且即便在很少的负载下也不能服务多个客户端，但它对于我们的讨论很有用，因为我们需要的是一个易于理解的基础。
|
||||
|
||||
这个服务器的完整代码在 [这里][11]；接下来，我会着重于高亮的部分。`main` 函数里面的外层循环用于监听套接字，以便接受新客户端的连接。一旦有客户端进行连接，就会调用 `serve_connection`，这个函数中的代码会一直运行，直到客户端断开连接。
|
||||
|
||||
有序服务器在循环里调用 `accept` 用来监听套接字，并接受新连接：
|
||||
|
||||
```
|
||||
while (1) {
|
||||
struct sockaddr_in peer_addr;
|
||||
socklen_t peer_addr_len = sizeof(peer_addr);
|
||||
|
||||
int newsockfd =
|
||||
accept(sockfd, (struct sockaddr*)&peer_addr, &peer_addr_len);
|
||||
|
||||
if (newsockfd < 0) {
|
||||
perror_die("ERROR on accept");
|
||||
}
|
||||
|
||||
report_peer_connected(&peer_addr, peer_addr_len);
|
||||
serve_connection(newsockfd);
|
||||
printf("peer done\n");
|
||||
}
|
||||
```
|
||||
|
||||
`accept` 函数每次都会返回一个新的已连接的套接字，然后服务器调用 `serve_connection`；注意这是一个 _阻塞式_ 的调用 —— 在 `serve_connection` 返回前，`accept` 函数都不会再被调用了；服务器会被阻塞，直到客户端结束连接才能接受新的连接。换句话说，客户端按 _顺序_ 得到响应。
|
||||
|
||||
这是 `serve_connection` 函数：
|
||||
|
||||
```
|
||||
typedef enum { WAIT_FOR_MSG, IN_MSG } ProcessingState;
|
||||
|
||||
void serve_connection(int sockfd) {
|
||||
if (send(sockfd, "*", 1, 0) < 1) {
|
||||
perror_die("send");
|
||||
}
|
||||
|
||||
ProcessingState state = WAIT_FOR_MSG;
|
||||
|
||||
while (1) {
|
||||
uint8_t buf[1024];
|
||||
int len = recv(sockfd, buf, sizeof buf, 0);
|
||||
if (len < 0) {
|
||||
perror_die("recv");
|
||||
} else if (len == 0) {
|
||||
break;
|
||||
}
|
||||
|
||||
for (int i = 0; i < len; ++i) {
|
||||
switch (state) {
|
||||
case WAIT_FOR_MSG:
|
||||
if (buf[i] == '^') {
|
||||
state = IN_MSG;
|
||||
}
|
||||
break;
|
||||
case IN_MSG:
|
||||
if (buf[i] == '$') {
|
||||
state = WAIT_FOR_MSG;
|
||||
} else {
|
||||
buf[i] += 1;
|
||||
if (send(sockfd, &buf[i], 1, 0) < 1) {
|
||||
perror("send error");
|
||||
close(sockfd);
|
||||
return;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
close(sockfd);
|
||||
}
|
||||
```
|
||||
|
||||
它完全是按照状态机协议进行编写的。每次循环的时候，服务器尝试接收客户端的数据。收到 0 字节意味着客户端断开连接，然后循环就会退出。否则，会逐字节检查接收缓存，每一个字节都可能会触发一个状态。
|
||||
|
||||
`recv` 函数返回接收到的字节数与客户端发送消息的数量完全无关（`^...$` 闭合序列的字节）。因此，在保持状态的循环中，遍历整个缓冲区很重要。而且，每一个接收到的缓冲中可能包含多条信息，但也有可能开始了一个新消息，却没有显式的结束字符；而这个结束字符可能在下一个缓冲中才能收到，这就是处理状态在循环迭代中进行维护的原因。
|
||||
|
||||
例如，试想主循环中的 `recv` 函数在某次连接中返回了三个非空的缓冲：
|
||||
|
||||
1. `^abc$de^abte$f`
|
||||
|
||||
2. `xyz^123`
|
||||
|
||||
3. `25$^ab$abab`
|
||||
|
||||
服务端返回的是哪些数据？追踪代码对于理解状态转变很有用。（答案见 [ [2][12] ]）
|
||||
|
||||
### 多个并发客户端
|
||||
|
||||
如果多个客户端在同一时刻向有序服务器发起连接会发生什么事情？
|
||||
|
||||
服务器端的代码（以及它的名字 `有序的服务器`）已经说的很清楚了，一次只能处理 _一个_ 客户端的请求。只要服务器在 `serve_connection` 函数中忙于处理客户端的请求，就不会接受别的客户端的连接。只有当前的客户端断开了连接，`serve_connection` 才会返回，然后最外层的循环才能继续执行接受其他客户端的连接。
|
||||
|
||||
为了演示这个行为，[该系列教程的示例代码][13] 包含了一个 Python 脚本，用于模拟几个想要同时连接服务器的客户端。每一个客户端发送类似之前那样的三个数据缓冲 [ [3][14] ]，不过每次发送数据之间会有一定延迟。
|
||||
|
||||
客户端脚本在不同的线程中并发地模拟客户端行为。这是我们的序列化服务器与客户端交互的信息记录：
|
||||
|
||||
```
|
||||
$ python3.6 simple-client.py -n 3 localhost 9090
|
||||
INFO:2017-09-16 14:14:17,763:conn1 connected...
|
||||
INFO:2017-09-16 14:14:17,763:conn1 sending b'^abc$de^abte$f'
|
||||
INFO:2017-09-16 14:14:17,763:conn1 received b'b'
|
||||
INFO:2017-09-16 14:14:17,802:conn1 received b'cdbcuf'
|
||||
INFO:2017-09-16 14:14:18,764:conn1 sending b'xyz^123'
|
||||
INFO:2017-09-16 14:14:18,764:conn1 received b'234'
|
||||
INFO:2017-09-16 14:14:19,764:conn1 sending b'25$^ab0000$abab'
|
||||
INFO:2017-09-16 14:14:19,765:conn1 received b'36bc1111'
|
||||
INFO:2017-09-16 14:14:19,965:conn1 disconnecting
|
||||
INFO:2017-09-16 14:14:19,966:conn2 connected...
|
||||
INFO:2017-09-16 14:14:19,967:conn2 sending b'^abc$de^abte$f'
|
||||
INFO:2017-09-16 14:14:19,967:conn2 received b'b'
|
||||
INFO:2017-09-16 14:14:20,006:conn2 received b'cdbcuf'
|
||||
INFO:2017-09-16 14:14:20,968:conn2 sending b'xyz^123'
|
||||
INFO:2017-09-16 14:14:20,969:conn2 received b'234'
|
||||
INFO:2017-09-16 14:14:21,970:conn2 sending b'25$^ab0000$abab'
|
||||
INFO:2017-09-16 14:14:21,970:conn2 received b'36bc1111'
|
||||
INFO:2017-09-16 14:14:22,171:conn2 disconnecting
|
||||
INFO:2017-09-16 14:14:22,171:conn0 connected...
|
||||
INFO:2017-09-16 14:14:22,172:conn0 sending b'^abc$de^abte$f'
|
||||
INFO:2017-09-16 14:14:22,172:conn0 received b'b'
|
||||
INFO:2017-09-16 14:14:22,210:conn0 received b'cdbcuf'
|
||||
INFO:2017-09-16 14:14:23,173:conn0 sending b'xyz^123'
|
||||
INFO:2017-09-16 14:14:23,174:conn0 received b'234'
|
||||
INFO:2017-09-16 14:14:24,175:conn0 sending b'25$^ab0000$abab'
|
||||
INFO:2017-09-16 14:14:24,176:conn0 received b'36bc1111'
|
||||
INFO:2017-09-16 14:14:24,376:conn0 disconnecting
|
||||
```
|
||||
|
||||
这里要注意连接名：`conn1` 是第一个连接到服务器的，先跟服务器交互了一段时间。接下来的连接 `conn2` —— 在第一个断开连接后，连接到了服务器，然后第三个连接也是一样。就像日志显示的那样，每一个连接让服务器变得繁忙，保持大约 2.2 秒的时间（这实际上是人为地在客户端代码中加入的延迟），在这段时间里别的客户端都不能连接。
|
||||
|
||||
显然，这不是一个可扩展的策略。这个例子中，客户端中加入了延迟，让服务器不能处理别的交互动作。一个智能服务器应该能处理一堆客户端的请求，而这个原始的服务器在结束连接之前一直繁忙（我们将会在之后的章节中看到如何实现智能的服务器）。尽管服务端有延迟，但这不会过度占用CPU；例如，从数据库中查找信息（时间基本上是花在连接到数据库服务器上，或者是花在硬盘中的本地数据库）。
|
||||
|
||||
### 总结及期望
|
||||
|
||||
这个示例服务器达成了两个预期目标：
|
||||
|
||||
1. 首先是介绍了问题范畴和贯彻该系列文章的套接字编程基础。
|
||||
|
||||
2. 对于并发服务器编程的抛砖引玉 —— 就像之前的部分所说，有序服务器还不能在几个轻微的负载下进行扩展，而且没有高效的利用资源。
|
||||
|
||||
在看下一篇文章前，确保你已经理解了这里所讲的服务器/客户端协议，还有有序服务器的代码。我之前介绍过了这个简单的协议；例如 [串行通信分帧][15] 和 [协同运行，作为状态机的替代][16]。要学习套接字网络编程的基础，[Beej's 教程][17] 用来入门很不错，但是要深入理解我推荐你还是看本书。
|
||||
|
||||
如果有什么不清楚的，请在评论区下进行评论或者向我发送邮件。深入理解并发服务器！
|
||||
|
||||
***
|
||||
|
||||
|
||||
[ [1][1] ] 状态转变中的 In/Out 记号是指 [Mealy machine][2]。
|
||||
|
||||
[ [2][3] ] 回应的是 `bcdbcuf23436bc`。
|
||||
|
||||
[ [3][4] ] 这里在结尾处有一点小区别，加了字符串 `0000` —— 服务器回应这个序列，告诉客户端让其断开连接；这是一个简单的握手协议，确保客户端有足够的时间接收到服务器发送的所有回复。
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
via: https://eli.thegreenplace.net/2017/concurrent-servers-part-1-introduction/
|
||||
|
||||
作者：[Eli Bendersky][a]
|
||||
译者：[GitFuture](https://github.com/GitFuture)
|
||||
校对：[校对者ID](https://github.com/校对者ID)
|
||||
|
||||
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||||
|
||||
[a]:https://eli.thegreenplace.net/pages/about
|
||||
[1]:https://eli.thegreenplace.net/2017/concurrent-servers-part-1-introduction/#id1
|
||||
[2]:https://en.wikipedia.org/wiki/Mealy_machine
|
||||
[3]:https://eli.thegreenplace.net/2017/concurrent-servers-part-1-introduction/#id2
|
||||
[4]:https://eli.thegreenplace.net/2017/concurrent-servers-part-1-introduction/#id3
|
||||
[5]:https://eli.thegreenplace.net/tag/concurrency
|
||||
[6]:https://eli.thegreenplace.net/tag/c-c
|
||||
[7]:http://eli.thegreenplace.net/2017/concurrent-servers-part-1-introduction/
|
||||
[8]:http://eli.thegreenplace.net/2017/concurrent-servers-part-2-threads/
|
||||
[9]:http://eli.thegreenplace.net/2017/concurrent-servers-part-3-event-driven/
|
||||
[10]:https://eli.thegreenplace.net/2017/concurrent-servers-part-1-introduction/#id4
|
||||
[11]:https://github.com/eliben/code-for-blog/blob/master/2017/async-socket-server/sequential-server.c
|
||||
[12]:https://eli.thegreenplace.net/2017/concurrent-servers-part-1-introduction/#id5
|
||||
[13]:https://github.com/eliben/code-for-blog/tree/master/2017/async-socket-server
|
||||
[14]:https://eli.thegreenplace.net/2017/concurrent-servers-part-1-introduction/#id6
|
||||
[15]:http://eli.thegreenplace.net/2009/08/12/framing-in-serial-communications/
|
||||
[16]:http://eli.thegreenplace.net/2009/08/29/co-routines-as-an-alternative-to-state-machines
|
||||
[17]:http://beej.us/guide/bgnet/
|
||||
[18]:https://eli.thegreenplace.net/2017/concurrent-servers-part-1-introduction/
|
||||
144
translated/tech/The changing face of the hybrid cloud
Normal file
144
translated/tech/The changing face of the hybrid cloud
Normal file
@ -0,0 +1,144 @@
|
||||
-混合云的变化
|
||||
-============================================================
|
||||
-
|
||||
-### 云计算的概念和术语仍然是新的，但是也在不断的改进。
|
||||
-
|
||||
-
|
||||
-
|
||||
-图像来源 :
|
||||
-
|
||||
-[Flickr使用者: theaucitron][9] (CC BY-SA 2.0)
|
||||
-
|
||||
-根据开始的时间计算，云计算只有十多年的发展时间。一些我们习以为常的云计算的概念和术语仍然还是新的。美国国家标准与
|
||||
|
||||
技术研究所(NIST)证明，一些已经被定义的熟悉的术语在2011年才被出版，例如基础设施即服务(IaaS)，即使在此之前它以草稿的
|
||||
|
||||
形式广泛流传。
|
||||
-
|
||||
-在这些定义中，有一个定义了混合云。回看术语在这段期间的变化是很有启发性的。云基础设施已经越过了一个相对简单的分类
|
||||
|
||||
。同时，它突出的如何优先熟悉开源软件的使用者，例如灵活性，可移植性，选择性，已经被运用到了混合云上。
|
||||
-
|
||||
-探索开源云
|
||||
-
|
||||
-* [什么是云？][1]
|
||||
-
|
||||
-* [什么是OpenStack？][2]
|
||||
-
|
||||
-* [什么是Kubernetes？][3]
|
||||
-
|
||||
-* [为什么操作系统对容器是重要的？][4]
|
||||
-
|
||||
-* [保持linux容器的安全和可靠][5]
|
||||
-
|
||||
-NIST对混合云最初的定义主要集中于云爆发。你能使用预置的基础设施去处理一个基本的计算负荷，但是如果你的负荷量暴涨，
|
||||
|
||||
将转为使用公有云。与之密切联系的是加强私有云与公有云之间API的兼容性，甚至是创造一个现货市场来提供最便宜的容量。
|
||||
-
|
||||
-Nick Carr在The Big Switch一书中提出一个概念，云是一种计算工具，其与输电网类似。他因为一个很好的构想被发明出来，但
|
||||
|
||||
是它与电网一样的局限性变得明显。计算不是以电流方式呈现的一种物品。不是只要简单的看看公有云提供商新增加的功能就可以
|
||||
|
||||
了，例如也在OpenStack一类的开源云软件上，许多用户不仅仅是寻找最便宜的计算周期。
|
||||
-
|
||||
-云爆发的概念大部分地忽略了计算是与数据相联系的现实。你不可能只移动洪水般突如其来的数据而不承担巨大的带宽费用，以
|
||||
|
||||
及担心转移需要花费的时间。Dave McCrory发明了“data gravity”一词去描述这个限制。
|
||||
-
|
||||
-我给出了混合云负面的影响，那为什么我们现在还要过多的讨论混合云？
|
||||
-
|
||||
-正如我说的，混合云的最初的构想是在云爆发的背景下诞生的。云爆发强调的是快速甚至是即时的将工作环境从一个云转移到另
|
||||
|
||||
一个云上。然而，混合云也意味着应用和数据的移植性。确实，2011年我在CNET的回传中写到：“我认为过度的关注于全自动的工
|
||||
|
||||
作转换给我们自己造成了困扰”当我们关心的是数据从一个地方到另一个地方的迁移能力的时候，如果供应商没有响应我们的请求
|
||||
|
||||
或者尝试将我们锁定。
|
||||
-
|
||||
-从那以后，探索云之间的移植性有了进一步的进展
|
||||
-
|
||||
-Linux是云移植性的关键因为它能维持应用从裸机移植到预置虚拟基础设施以及从私有云移植到公有云的过程中持续运行。Linux
|
||||
|
||||
提供了一个完整可靠的平台，其具有稳定的API接口，且可以依靠这些接口编写程序。
|
||||
-
|
||||
-被广泛采纳的容器进一步加强了linux提供应用在云之间移植的能力。通过提供一个包含应用基础配置环境的镜像，应用在开发、
|
||||
|
||||
测试和最终运行环境之间移动时容器提供了可移植性和兼容性。
|
||||
-
|
||||
-Linux 容器被应用到许多要求可移植性，可配置性以及独立性的问题上。不管是预置好的公有云还是混合云都是如此。
|
||||
-
|
||||
-容器使用的是基于映像的部署模式，这让分享一个应用或者是在不同环境中构建需要相同基础配置的服务变得容易了。
|
||||
-
|
||||
-在OCI帮助下发展的规格定义了容器的内容和其所依赖的东西、环境、参数和一些镜像正确运行所必须的要求。在标准化的作用下
|
||||
|
||||
，OCI为需要依靠稳定的运行时间和镜像空间来运行的工具提供了一个机会。
|
||||
-
|
||||
-同时，通过Gluster和Ceph这类的开源技术，分布式存储能提供数据在云上的可移植性。 物理约束限制了如何快速简单地把数据
|
||||
|
||||
从一个地方移动到另一个地方，但是由于集中式部署以及不同类型基础设施的使用，他们越来越渴望一个不受物理、虚拟和云资源
|
||||
|
||||
限制的开源软件定义储存平台
|
||||
-
|
||||
-尤其是在数据存储需求飞速增长的情况下，由于预测分析，物联网和实时监控的趋势。2016年的一项研究表明，98%的IT决策者认
|
||||
|
||||
为一个更敏捷的存储解决方案对他们的组织是有利的。在同一个研究中，他们列举出不恰当的存储基础设施作为最令他们组织受挫
|
||||
|
||||
的事情之一。
|
||||
-
|
||||
-混合云表现出的是提供在不同计算能力和资源之间合适的移植性和兼容性。其不仅仅是将私有云和公有云同时运用在一个应用中
|
||||
|
||||
。他是使用多种类型的一套服务，其中的一部分可能是你们IT部门建立和操作的，而另一部分可能来源于外部。
|
||||
-
|
||||
-他们可能是软件即服务应用的混合，例如邮件和客户关系管理。被Kubernetes这类开源软件协调在一起的容器平台越来越受新开
|
||||
|
||||
发应用的欢迎。你的组织可能正在运用某一家大型云服务提供商来做一些事情。同时你也能在私有云或更加传统的预置基础设施上
|
||||
|
||||
操作一些你自己的基础设施。
|
||||
-
|
||||
-这就是现在混合云的现状，它能被归纳为两个选择，选择最合适的基础设施和服务以及选择把应用和数据从一个地方移动到另一
|
||||
|
||||
个你想的地方。
|
||||
-
|
||||
- **_相关阅读: [多重云和混合云有什么不同？][6]_**
|
||||
-
|
||||
---------------------------------------------------------------------------------
|
||||
-
|
||||
-作者简介：
|
||||
-
|
||||
-Gordon Haff是红帽子云的传播者，常受到业内和客户的高度赞赏，帮助红帽子云组合方案的发展。他是Computing Next: How
|
||||
|
||||
the Cloud Opens the Future的作者，除此之外他还有许多出版物的。在红帽之前，Gordon写了大量的研究简报，经常被纽约时报
|
||||
|
||||
等出版物在IT类话题上引用，在产品和市场策略上给予客户建议。他职业生涯的早期，在Data General他负责将各种不同的计算机
|
||||
|
||||
系统，从微型计算机到大型的UNIX服务器，引入市场。他有麻省理工学院和达特茅斯学院的工程学位，还是康奈尔大学约翰逊商学
|
||||
|
||||
院的工商管理学硕士。
|
||||
-
|
||||
-
|
||||
-via: https://opensource.com/article/17/7/hybrid-cloud
|
||||
-
|
||||
-作者：[ Gordon Haff (Red Hat) ][a]
|
||||
-译者：[译者ID](https://github.com/ZH1122)
|
||||
-校对：[校对者ID](https://github.com/校对者ID)
|
||||
-
|
||||
-本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||||
-
|
||||
-[a]:https://opensource.com/users/ghaff
|
||||
-[1]:https://opensource.com/resources/cloud?src=cloud_resource_menu1
|
||||
-[2]:https://opensource.com/resources/what-is-openstack?src=cloud_resource_menu2
|
||||
-[3]:https://opensource.com/resources/what-is-kubernetes?src=cloud_resource_menu3
|
||||
-[4]:https://opensource.com/16/12/yearbook-why-operating-system-matters?src=cloud_resource_menu4
|
||||
-[5]:https://opensource.com/business/16/10/interview-andy-cathrow-anchore?src=cloud_resource_menu5
|
||||
-[6]:https://enterprisersproject.com/article/2017/7/multi-cloud-vs-hybrid-cloud-whats-difference
|
||||
-[7]:https://opensource.com/article/17/7/hybrid-cloud?rate=ztmV2D_utD03cID1u41Al08w0XFm6rXXwCJdTwqI4iw
|
||||
-[8]:https://opensource.com/user/21220/feed
|
||||
-[9]:https://www.flickr.com/photos/theaucitron/5810163712/in/photolist-5p9nh3-6EkSKG-6EgGEF-9hYBcr-abCSpq-9zbjDz-4PVqwm-9RqBfq-abA2T4-4nXfwv-9RQkdN-dmjSdA-84o2ER-abA2Wp-ehyhPC-7oFYrc-4nvqBz-csMQXb-nRegFf-ntS23C-nXRyaB-6Xw3Mq-cRMaCq-b6wkkP-7u8sVQ-yqcg-6fTmk7-bzm3vU-6Xw3vL-6EkzCQ-d3W8PG-5MoveP-oMWsyY-jtMME6-XEMwS-2SeRXT-d2hjzJ-p2ZZVZ-7oFYoX-84r6Mo-cCizvm-gnnsg5-77YfPx-iDjqK-8gszbW-6MUZEZ-dhtwtk-gmpTob-6TBJ8p-mWQaAC/
|
||||
-[10]:http://www.nicholascarr.com/?page_id=21
|
||||
-[11]:https://www.cnet.com/news/there-is-no-big-switch-for-cloud-computing/
|
||||
-[12]:https://www.cnet.com/news/cloudbursting-or-just-portable-clouds/
|
||||
-[13]:https://www.redhat.com/en/technologies/storage/vansonbourne
|
||||
-[14]:https://opensource.com/users/ghaff
|
||||
-[15]:https://opensource.com/users/ghaff
|
||||
Loading…
Reference in New Issue
Block a user