小编Vit*_*aev的帖子

在提交错误之前,我想请某人确认docker build我最近面临的奇怪行为.

考虑我们有一个简单的Dockerfile,我们试图将一些文件复制到非root用户的主目录中:

FROM ubuntu:utopic

ENV DEBIAN_FRONTEND=noninteractive

RUN sed -i.bak 's/http:\/\/archive.ubuntu.com\/ubuntu\//mirror:\/\/mirrors.ubuntu.com\/mirrors.txt\//g' /etc/apt/sources.list
RUN echo "deb http://repo.aptly.info/ squeeze main" >> /etc/apt/sources.list.d/_aptly.list
RUN apt-key adv --keyserver keys.gnupg.net --recv-keys e083a3782a194991
RUN apt-get update
RUN apt-get install -y aptly

RUN useradd -m aptly
RUN echo aptly:aptly | chpasswd

USER aptly
COPY ./.aptly.conf $HOME/.aptly.conf

COPY ./public.key $HOME/public.key
COPY ./signing.key $HOME/signing.key
RUN gpg --import $HOME/public.key $HOME/signing.key

RUN aptly repo create -comment='MAILPAAS components' -distribution=utopic -component=main mailpaas
CMD ["/usr/bin/aptly", "api", "serve"]

这是我在尝试构建此图像时得到的结果:

    ...    
    Step 10 : …

我正在研究用Python编写的某种系统服务(实际上它只是一个日志解析器).这个程序应该连续工作很长时间(希望我的意思是几天和几周没有失败和重新启动的需要).这就是为什么我担心内存消耗.

我将来自不同站点的进程内存使用情况的不同信息汇总到一个简单的函数中:

#!/usr/bin/env python
from pprint import pprint
from guppy import hpy
from datetime import datetime
import sys
import os
import resource
import re

def debug_memory_leak():
    #Getting virtual memory size 
    pid = os.getpid()
    with open(os.path.join("/proc", str(pid), "status")) as f:
        lines = f.readlines()
    _vmsize = [l for l in lines if l.startswith("VmSize")][0]
    vmsize = int(_vmsize.split()[1])

    #Getting physical memory size  
    pmsize = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss

    #Analyzing the dynamical memory segment - total number of objects in memory and heap size
    h = hpy().heap()
    if …

我有以下docker文件,我想专门安装我的磁盘上可用的rpm文件,因为我正在构建docker实例.我对rpm install的调用看起来像这样.命令 RUN rpm -i chrpath-0.13-14.el7.x86_64.rpm失败.

有没有办法在本地安装rpm文件到新的Docker实例？

FROM centos:latest
    RUN yum -y install yum-utils
    RUN yum -y install python-setuptools
    RUN easy_install supervisor
    RUN mkdir -p /var/log/supervisor
    RUN yum -y install which
    RUN yum -y install git
    # Basic build dependencies.
    RUN yum -y install  autoconf build-essential unzip zip
    # Gold linker is much faster than standard linker.
    RUN yum -y install  binutils
    # Developer tools.
    RUN yum -y install bash-completion curl emacs git man-db python-dev python-pip vim tar
    RUN …

为了使切片附加操作更快,我们需要分配足够的容量.有两种方法可以追加切片,这是代码:

func BenchmarkSliceAppend(b *testing.B) {
    a := make([]int, 0, b.N)
    for i := 0; i < b.N; i++ {
        a = append(a, i)
    }
}

func BenchmarkSliceSet(b *testing.B) {
    a := make([]int, b.N)
    for i := 0; i < b.N; i++ {
        a[i] = i
    }
}

结果是:

BenchmarkSliceAppend-4 200000000 7.87 ns/op 8 B/op 0 allocs/op

BenchmarkSliceSet-4 300000000 5.76 ns/op 8 B/op

a[i] = i比a = append(a, i)我快,我想知道为什么？

我对 GRPC 比较陌生，希望确保我正在使用 golang 正确进行连接管理。我不想为每次调用都创建一个新连接，但我也不想在扩展时产生瓶颈。

我所做的是在 init 函数中创建一个连接：

var userConn *grpc.ClientConn
var userServiceName string

func init() {
    userServiceName := os.Getenv("USER_SERVICE_URL")
    if userServiceName == "" {
        userServiceName = "localhost"
    }
    logging.LogDebug("userClient:  Connecting to: "+userServiceName, "")
    tempConn, err := grpc.Dial(userServiceName, grpc.WithInsecure())
    if err != nil {
        logging.LogEmergency("account_user_client.Init()  Could not get the connection.  "+err.Error(), "")
        return
    }
    userConn = tempConn
}

然后对于每个函数，我将使用该连接创建一个客户端：

c := user.NewUserClient(userConn)
// Contact the server and print out its response.
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
r, err …

如果应用程序使用多个文件描述符(例如,打开 - 写入数据 - 同步 - 关闭)进行了一些繁重的工作,那么Go运行时会发生什么？当昂贵的系统调用发生时(例如syscall.Fsync)它是否会阻止所有goroutine ？或者只有调用goroutine被阻止而其他人仍在运行？

那么编写具有多个用户空间的多个工作程序的程序是有意义的 - 内核空间上下文切换？使用多线程模式进行磁盘输入是否有意义？

package main

import (
    "log"
    "os"
    "sync"
)

var data = []byte("some big data")

func worker(filenamechan chan string, wg *sync.waitgroup) {
    defer wg.done()
    for {
        filename, ok := <-filenamechan
        if !ok {
            return
        }

        // open file is a quite expensive operation due to
        // the opening new descriptor
        f, err := os.openfile(filename, os.o_create|os.o_wronly, os.filemode(0644))
        if err != nil {
            log.fatal(err)
            continue
        }

        // write is a …

与此问题相关,命名互斥锁的最佳做法是什么？我意识到这可能会因操作系统甚至版本(尤其是Windows)而有所不同,所以请在回答时指定平台.我的兴趣在于Win XP和Vista.

我将此作为问题/答案发布,因为我花了一段时间才解决问题,我不介意对我的解决方案提出一些反馈意见.在Go/CGo中,如何使用作为指针传递的C数组？

例如,使用此C结构:

struct _GNetSnmpVarBind {                     
    guint32     *oid;       /* name of the variable */
    gsize       oid_len;    /* length of the name */
    ... and other fields
};  

我想将oid字段转换为Go字符串,我将如何使用guint32*指针？

我正在使用OpenSSL API开发应用程序.众所周知,OpenSSL使用全局变量的miriades,由Valgrind作为错误("条件跳转或移动......"等).因此,Valgrind的输出被共享库中的错误堵塞.这对于调试来说非常不方便,因为每次我得到:

检测到超过X个总错误.我不再报告了.最终错误计数将不准确.去修复你的程序吧!

问题是:

1. 我可以在Valgrind中禁用派对库(在我的情况下为-lssl和-lcrypto)内存检查吗？

2. 或者我可以只关注"明确丢失"的错误吗？

   谢谢.

我们使用两个众所周知的概念实现我们的持续集成和持续交付流程:Linux二进制包和Docker图像.

大部分工作已经完成:我们从GitLabrepo 获取代码,编译它并放入deb存储的包中Aptly,然后我们Docker为我们拥有的每个服务创建图像并将图像推送到私有Docker Registry服务器.然后将这些图像滚动到测试环境.最后,我们启动服务并执行验收测试.这是一个连续的过程,每当有人推送时,它就会启动origin/master.

目前尚不清楚的是如何区分存储在Docker Registry中的稳定图像？

我们必须跟踪每个图像的状态,因为我们需要执行稳定服务器的定期更新.显然,某些版本(即图像版本)不会通过验收测试,必须标记为不可用,并在每次下一次持续交付迭代时过滤掉.

似乎没有此功能的默认实现:

1. 默认图像repo/tag是一个普通的普通字符串,不能同时包含版本号,构建日期和QA标记.
2. Labels(在1.6中介绍)可能是解决方法的良好起点,但我们无法找到重新标记现有图像的机会(请注意,我们需要在考虑QA结果的情况下更新图像"元数据").没有可用的方法通过标签值查询图像,但我们可能会包装Docker API.

那么将版本分配给Docker Images的正确方法是什么？如何存储质量保证相关信息？我们如何"突出"稳定的图像构建？Jenkins CI可以使用哪些功能来达到这些目的？请分享您的经验.

UPD:过了一段时间我不得不在Docker问题跟踪器中开始讨论.可能有人会发现它也很有用.