小编agn*_*aft的帖子

I am trying to get a grip around the packing and unpacking of binary data in Python 3. Its actually not that hard to understand, except one problem:

what if I have a variable length textstring and want to pack and unpack this in the most elegant manner?

As far as I can tell from the manual I can only unpack fixed size strings directly? In that case, are there any elegant way of getting around this limitation without padding …

我目前正在研究使用websockets在客户端/代理和服务器之间进行通信,并决定为此目的查看C#.虽然之前我曾经使用过Websockets和C#,但这是我第一次使用它们.第一次尝试使用以下指南:http: //www.codeproject.com/Articles/618032/Using-WebSocket-in-NET-Part

public static void Main(string[] args)
{
    Task t = Echo();
    t.Wait();
}

private static async Task Echo()
{
    using (ClientWebSocket ws = new ClientWebSocket())
    {
        Uri serverUri = new Uri("ws://localhost:49889/");
        await ws.ConnectAsync(serverUri, CancellationToken.None);
        while (ws.State == WebSocketState.Open)
        {
            Console.Write("Input message ('exit' to exit): ");
            string msg = Console.ReadLine();
            if (msg == "exit")
            {
                break;
            }
            ArraySegment<byte> bytesToSend = new ArraySegment<byte>(Encoding.UTF8.GetBytes(msg));
            await ws.SendAsync(bytesToSend, WebSocketMessageType.Text, true, CancellationToken.None);
            ArraySegment<byte> bytesReceived = new ArraySegment<byte>(new byte[1024]);
            WebSocketReceiveResult result = await ws.ReceiveAsync(bytesReceived, …

我正在使用python(不是真正相关的)和Postgresql(如果相关的9.2)实现一个简单的基于Web的RSS阅读器.数据库模式如下(基于RSS格式):

CREATE TABLE feed_channel
(
    id SERIAL PRIMARY KEY,
    name TEXT,
    link TEXT NOT NULL,
    title TEXT
);
CREATE TABLE feed_content
(
    id SERIAL PRIMARY KEY,
    channel INTEGER REFERENCES feed_channel(id) ON DELETE CASCADE ON UPDATE CASCADE,
    guid TEXT UNIQUE NOT NULL,
    title TEXT,
    link TEXT,
    description TEXT,
    pubdate TIMESTAMP
);

当我创建新频道(以及查询更新的Feed信息)时,我请求Feed,将其数据插入feed_channel表,选择新插入的ID - 或现有以避免重复 - 然后将Feed数据添加到feed_content表.典型的情况是:

1. 查询Feed网址,抓取Feed标头和所有当前内容
2. 如果不存在,请将Feed标头插入feed_channel ...如果已存在,请抓取现有ID
3. 对于每个Feed项,请插入feed_content表,并引用存储的通道ID

这是标准的"插入(如果尚未存在,但返回相关ID")问题.为了解决这个问题,我实现了以下存储过程:

CREATE OR REPLACE FUNCTION channel_insert(
  p_link feed_channel.link%TYPE,
  p_title feed_channel.title%TYPE
) RETURNS feed_channel.id%TYPE AS $$
  DECLARE
    v_id feed_channel.id%TYPE;
  BEGIN
    SELECT id …

我试图在MongoDB中使用upsert更新文档中的单个字段(如果找到)或插入包含大量字段的整个新文档.问题是我觉得MongoDB要么替换每个字段,要么在其upsert操作中插入一个字段子集,即它不能插入比实际想要更新的字段更多的字段.

我想做的是以下内容:

• 我查询一个唯一值
• 如果文档已存在,则只将时间戳值(让我们称之为"lastseen")更新为新值
• 如果文档不存在,我将添加一长串不同的键/值对列表,这些键/值对应在其生命周期的剩余时间内保持静态.

让我们来说明:

如果找到'name',这个例子将从我的理解更新'lastseen'日期,但如果找不到'name',它只会插入'name'+'lastseen'.

db.somecollection.update({name: "some name"},{ $set: {"lastseen": "2012-12-28"}}, {upsert:true})

如果我向第二个参数添加了更多字段(键/值对)并删除了$ set,那么每个字段都会在更新时被替换,但会对插入产生所需的效果.是否有像插入或类似的东西只在插入时执行操作？

所以在我看来,我只能得到以下之一:

• 正确的更新行为,但如果文档不存在,则会插入仅包含所需字段子集的文档
• 正确的插入行为,但如果文档已存在,则会覆盖所有现有字段

我的理解是否正确？如果是这样,这可以通过一次操作解决吗？

据我所知,如果他们太忙,goroutines会阻止其他goroutines运行.对我来说,这意味着我的应用程序的性能和响应性可能取决于我知道哪些库方法将控制其他goroutine(例如通常是Read()和Write())

有什么方法我可以确切地知道不同的库方法将如何控制其他goroutine,即实际上没有阻止？

有没有办法可以实现一个调用第三方代码的新方法(包括依赖于waitforsingleobject或waitformultipleobjects的异步Win32 API,如findnextchangenotification),并且对Go调度程序表现"不错"？在这个特定的例子中,系统调用将在完成后发出信号,我需要等到它完成后不会耗尽所有其他goroutine.

是否还有另一个"最佳实践",如何处理Go中的第三方阻止操作,以便它们不会耗尽其他goroutines？

我假设Go运行时可能在后台线程上内部运行某种IO循环,以便"暂停"阻止goroutine操作,直到它们完成IO.如果情况确实如此,那么我认为能够在此基础上进行新的阻塞操作可能是有用的.

我注意到了新的System.IO.Pipelines,并试图将现有的基于流的代码移植到它上面.流的问题很好理解,但同时它具有丰富的相关类的回声系统.

从这里提供的示例中,有一个小的tcp echo服务器. https://blogs.msdn.microsoft.com/dotnet/2018/07/09/system-io-pipelines-high-performance-io-in-net/

代码片段附在此处:

    private static async Task ProcessLinesAsync(Socket socket)
    {
        Console.WriteLine($"[{socket.RemoteEndPoint}]: connected");

        var pipe = new Pipe();
        Task writing = FillPipeAsync(socket, pipe.Writer);
        Task reading = ReadPipeAsync(socket, pipe.Reader);

        await Task.WhenAll(reading, writing);

        Console.WriteLine($"[{socket.RemoteEndPoint}]: disconnected");
    }

    private static async Task FillPipeAsync(Socket socket, PipeWriter writer)
    {
        const int minimumBufferSize = 512;

        while (true)
        {
            try
            {
                // Request a minimum of 512 bytes from the PipeWriter
                Memory<byte> memory = writer.GetMemory(minimumBufferSize);

                int bytesRead = await socket.ReceiveAsync(memory, SocketFlags.None);
                if (bytesRead == 0)
                {
                    break; …

我正在尝试构建一个小型 tcp 服务器/守护进程，将 asp.net 核心作为 Web 前端与服务器进行交互。我发现 IHostedService/BackgroundService 似乎提供了一种将服​​务器和前端捆绑在一起的低成本替代方案。

代码目前看起来基本上是这样的（用于测试目的的回声服务器）：

public class Netcat : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        TcpListener listener = new TcpListener(IPAddress.Any, 8899);
        listener.Start();
        while(!stoppingToken.IsCancellationRequested)
        {
            TcpClient client = await listener.AcceptTcpClientAsync();
            NetworkStream stream = client.GetStream();

            while (!stoppingToken.IsCancellationRequested)
            {
                byte[] data = new byte[1024];
                int read = await stream.ReadAsync(data, 0, 1024, stoppingToken);

                await stream.WriteAsync(data, 0, read, stoppingToken);
            }
        }
    }
}

并在 Startup.cs 中初始化如下：

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddHostedService<Netcat>();
        services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
    }

对于现代 Asp.Net 核心应用程序和守护进程应该如何合作，是否有一个共同的模式？ …

在尝试提取html页面的标题时,我总是使用以下正则表达式:

(?<=<title.*>)([\s\S]*)(?=</title>)

这将提取文档中标记之间的所有内容,并忽略标记本身.但是,当尝试在Python中使用此正则表达式时,会引发以下异常:

Traceback (most recent call last):  
File "test.py", line 21, in <module>
    pattern = re.compile('(?<=<title.*>)([\s\S]*)(?=</title>)')
File "C:\Python31\lib\re.py", line 205, in compile
    return _compile(pattern, flags)   
File "C:\Python31\lib\re.py", line 273, in _compile
    p = sre_compile.compile(pattern, flags)   File
"C:\Python31\lib\sre_compile.py", line 495, in compile
    code = _code(p, flags)   File "C:\Python31\lib\sre_compile.py", line 480, in _code
_compile(code, p.data, flags)   File "C:\Python31\lib\sre_compile.py", line 115, in _compile
    raise error("look-behind requires fixed-width pattern")
sre_constants.error: look-behind requires fixed-width pattern

我使用的代码是:

pattern = re.compile('(?<=<title.*>)([\s\S]*)(?=</title>)')
m = pattern.search(f)

如果我做一些最小的调整它的工作原理:

pattern …

我正在使用Bottle上传相当大的文件.这个想法是,当文件上传时,Web应用程序运行(并忘记)一个系统命令,其中上传的文件路径作为参数.除了以正确的文件路径作为参数启动系统命令之外,我不需要保存文件,但我需要确保该文件在该过程完成处理之前可用.

我使用这里描述的确切代码:http: //bottlepy.org/docs/dev/tutorial.html#post-form-data-and-file-uploads

我的问题是:

• 瓶子存储上传文件在内存中或磁盘上的特定位置(或者像Flask,两者兼而有之)？
• 将上传的文件直接用于没有.read()的其他工具,然后手动将字节保存到磁盘上的指定文件中吗？
• 以文件作为参数启动系统命令的最佳方法是什么？是否可以直接将路径传递给现有文件？

我正在编写一个小型服务器,它将从多个来源接收数据并处理这些数据.收到的消息来源和数据非常重要,但epoll应该能够很好地处理.但是,必须解析所有接收到的数据并运行大量的测试,这些测试非常耗时,并且尽管进行了epoll多路复用,仍会阻塞单个线程.基本上,模式应该如下所示:IO循环接收数据并将其捆绑到作业中,发送到池中可用的第一个线程,捆绑由作业处理,结果传递到IO循环写入文件.

我决定选择一个IO线程和N个工作线程.使用以下示例提供的用于接受tcp连接和读取数据的IO线程很容易实现:http: //linux.die.net/man/7/epoll

线程通常也很容易处理,但我正在努力将epoll IO循环与线程池以优雅的方式结合起来.我无法找到任何与在线工作池使用epoll的"最佳实践",但有关同一主题的相关问题.

因此,我有一些问题,希望有人能帮我回答:

1. 可以(并且应该)使用eventfd作为IO线程和所有工作者之间双向同步的机制吗？例如,每个工作线程是否有一个好主意让自己的epoll例程等待共享的eventfd(带有结构指针,包含有关作业的数据/信息),即以某种方式使用eventfd作为作业队列？也许还有另一个eventfd将结果从多个工作线程传递回IO线程？
2. 在IO线程上发出关于套接字的更多数据的信号之后,实际的recv应该发生在IO线程上,还是工作者应该自己重新获取数据,以便在解析数据帧时不阻塞IO线程等？在这种情况下,我如何确保安全性,例如,如果recv在工作线程中读取1,5帧数据而另一个工作线程从同一连接接收最后0.5帧数据？
3. 如果工作线程池是通过互斥锁等实现的,如果N + 1个线程试图使用相同的锁,那么等待锁会阻塞IO线程吗？
4. 对于如何使用双向通信(即从IO到工作者和返回)在epoll周围构建工作线程池,是否有任何良好的实践模式？

编辑:一种可能的解决方案是从IO循环更新环形缓冲区,更新后通过所有工作人员的共享管道将环形缓冲区索引发送给工作者(从而将该索引的控制权交给第一个读取该索引的工作人员关闭管道索引),让工人拥有该索引直到处理结束,然后再通过管道将索引号发送回IO线程,从而给予回控制？

我的应用程序仅限Linux,因此我可以使用仅限Linux的功能,以便以最优雅的方式实现这一目标.不需要跨平台支持,但性能和线程安全性是必需的.