$ cargo new example
     Created binary (application) `example` package
$ cd example

fn leak() {
    let data = vec![0; 1024];
    std::mem::forget(data);
}

fn main() {
    leak();
}

#[cfg(test)]
mod test {
    use super::leak;

    #[test]
    fn test_leak() {
        leak();
    }
}

$ cargo build
   Compiling example v0.1.0 (/root/code/example)
    Finished dev [unoptimized + debuginfo] target(s) in 1.58s
$ valgrind target/debug/example
==1127561== Memcheck, a memory error detector
==1127561== Copyright (C) 2002-2022, and GNU GPL'd, by Julian Seward et al.
==1127561== Using Valgrind-3.19.0 and LibVEX; rerun with -h for copyright info
==1127561== Command: target/debug/example
==1127561==
==1127561==
==1127561== HEAP SUMMARY:
==1127561==     in use at exit: 4,096 bytes in 1 blocks
==1127561==   total heap usage: 11 allocs, 10 frees, 6,253 bytes allocated
==1127561==
==1127561== LEAK SUMMARY:
==1127561==    definitely lost: 4,096 bytes in 1 blocks
==1127561==    indirectly lost: 0 bytes in 0 blocks
==1127561==      possibly lost: 0 bytes in 0 blocks
==1127561==    still reachable: 0 bytes in 0 blocks
==1127561==         suppressed: 0 bytes in 0 blocks
==1127561== Rerun with --leak-check=full to see details of leaked memory
==1127561==
==1127561== For lists of detected and suppressed errors, rerun with: -s
==1127561== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

$ cargo test
   Compiling example v0.1.0 (/root/code/example)
    Finished test [unoptimized + debuginfo] target(s) in 1.37s
     Running unittests src/main.rs (target/debug/deps/example-64baa11f6262b62f)

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
$ valgrind target/debug/deps/example-64baa11f6262b62f
==1134151== Memcheck, a memory error detector
==1134151== Copyright (C) 2002-2022, and GNU GPL'd, by Julian Seward et al.
==1134151== Using Valgrind-3.19.0 and LibVEX; rerun with -h for copyright info
==1134151== Command: target/debug/deps/example-64baa11f6262b62f
==1134151==

running 1 test
test test::test_leak ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.26s

==1134151==
==1134151== HEAP SUMMARY:
==1134151==     in use at exit: 4,096 bytes in 1 blocks
==1134151==   total heap usage: 669 allocs, 668 frees, 72,979 bytes allocated
==1134151==
==1134151== LEAK SUMMARY:
==1134151==    definitely lost: 4,096 bytes in 1 blocks
==1134151==    indirectly lost: 0 bytes in 0 blocks
==1134151==      possibly lost: 0 bytes in 0 blocks
==1134151==    still reachable: 0 bytes in 0 blocks
==1134151==         suppressed: 0 bytes in 0 blocks
==1134151== Rerun with --leak-check=full to see details of leaked memory
==1134151==
==1134151== For lists of detected and suppressed errors, rerun with: -s
==1134151== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

$ cargo valgrind run
    Finished dev [unoptimized + debuginfo] target(s) in 0.02s
     Running `/root/.cargo/bin/cargo-valgrind target/debug/example`
       Error leaked 4.0 kiB in 1 block
        Info at calloc (vg_replace_malloc.c:1328)
             at alloc::alloc::alloc_zeroed (alloc.rs:160)
             at alloc::alloc::Global::alloc_impl (alloc.rs:171)
             at <alloc::alloc::Global as core::alloc::Allocator>::allocate_zeroed (alloc.rs:236)
             at alloc::raw_vec::RawVec<T,A>::allocate_in (raw_vec.rs:186)
             at alloc::raw_vec::RawVec<T,A>::with_capacity_zeroed_in (raw_vec.rs:139)
             at <T as alloc::vec::spec_from_elem::SpecFromElem>::from_elem (spec_from_elem.rs:54)
             at alloc::vec::from_elem (mod.rs:2454)
             at example::leak (main.rs:2)
             at example::main (main.rs:7)
             at core::ops::function::FnOnce::call_once (function.rs:248)
             at std::sys_common::backtrace::__rust_begin_short_backtrace (backtrace.rs:122)
     Summary Leaked 4.0 kiB total
$ cargo valgrind test
    Finished test [unoptimized + debuginfo] target(s) in 0.02s
     Running unittests src/main.rs (target/debug/deps/example-64baa11f6262b62f)

running 1 test
test test::test_leak ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.26s

       Error leaked 4.0 kiB in 1 block
        Info at calloc (vg_replace_malloc.c:1328)
             at alloc::alloc::alloc_zeroed (alloc.rs:160)
             at alloc::alloc::Global::alloc_impl (alloc.rs:171)
             at <alloc::alloc::Global as core::alloc::Allocator>::allocate_zeroed (alloc.rs:236)
             at alloc::raw_vec::RawVec<T,A>::allocate_in (raw_vec.rs:186)
             at alloc::raw_vec::RawVec<T,A>::with_capacity_zeroed_in (raw_vec.rs:139)
             at <T as alloc::vec::spec_from_elem::SpecFromElem>::from_elem (spec_from_elem.rs:54)
             at alloc::vec::from_elem (mod.rs:2454)
             at example::leak (main.rs:2)
             at example::test::test_leak (main.rs:16)
             at example::test::test_leak::{{closure}} (main.rs:15)
             at core::ops::function::FnOnce::call_once (function.rs:248)
     Summary Leaked 4.0 kiB total
error: test failed, to rerun pass '--bin example'

$ CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUNNER="valgrind --error-exitcode=1" cargo test
    Finished test [unoptimized + debuginfo] target(s) in 0.03s
     Running unittests src/main.rs (target/debug/deps/example-64baa11f6262b62f)
==1136560== Memcheck, a memory error detector
==1136560== Copyright (C) 2002-2022, and GNU GPL'd, by Julian Seward et al.
==1136560== Using Valgrind-3.19.0 and LibVEX; rerun with -h for copyright info
==1136560== Command: /root/code/example/target/debug/deps/example-64baa11f6262b62f
==1136560==

running 1 test
test test::test_leak ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.27s

==1136560==
==1136560== HEAP SUMMARY:
==1136560==     in use at exit: 4,096 bytes in 1 blocks
==1136560==   total heap usage: 669 allocs, 668 frees, 72,998 bytes allocated
==1136560==
==1136560== LEAK SUMMARY:
==1136560==    definitely lost: 4,096 bytes in 1 blocks
==1136560==    indirectly lost: 0 bytes in 0 blocks
==1136560==      possibly lost: 0 bytes in 0 blocks
==1136560==    still reachable: 0 bytes in 0 blocks
==1136560==         suppressed: 0 bytes in 0 blocks
==1136560== Rerun with --leak-check=full to see details of leaked memory
==1136560==
==1136560== For lists of detected and suppressed errors, rerun with: -s
==1136560== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

# 先新建目录
mkdir -p /mnt/aliyundrive /etc/aliyundrive-fuse
# 挂载磁盘
aliyundrive-fuse -r your-refresh-token -w /etc/aliyundrive-fuse /mnt/aliyundrive

docker run -d --name jellyfin \
  -v /root/jellyfin/config:/config \
  -v /root/jellyfin/cache:/cache \
  -v /mnt/aliyundrive:/media \
  -p 8096:8096 \
  --device=/dev/dri/renderD128 \
  --device /dev/dri/card0:/dev/dri/card0 \
  --restart unless-stopped \
  jellyfin/jellyfin

apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: kafka-scaledobject
  namespace: default
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: brm-index-basic
  pollingInterval: 10
  minReplicaCount: 1
  maxReplicaCount: 20
  triggers:
    - type: kafka
      metadata:
        bootstrapServers: kafka-server:9092
        consumerGroup: basic
        topic: basic
        lagThreshold: "100"
        offsetResetPolicy: latest

$ kubectl get hpa
NAME                                                    REFERENCE                                        TARGETS               MINPODS   MAXPODS   REPLICAS   AGE
keda-hpa-kafka-scaledobject-basic                       Deployment/brm-index-basic                       39500m/100 (avg)      1         20        2          5d22h

$ tree -L 2 .
.
├── CMakeLists.txt        # 项目主 CMake 配置
├── absl.pxd              # abseil-cpp 接口的部分 Cython 定义文件
├── hello                 # hello Python 库
│   ├── CMakeLists.txt    # Python C++ 扩展 CMake 配置
│   ├── __init__.py
│   └── _hello.pyx        # Cython 文件
├── pyproject.toml
├── setup.py
├── src
│   ├── CMakeLists.txt    # 项目 C/C++ 代码 CMake 配置
│   ├── absl.cc
│   └── absl.h
├── test_hello_cython.py  # 测试代码
├── vendor                # C/C++ 第三方库放置路径
│   └── abseil-cpp        # abseil-cpp Git submodule
└── venv                  # Python virtualenv

git submodule add --depth 50 https://github.com/abseil/abseil-cpp.git vendor/abseil-cpp

cmake_minimum_required(VERSION 3.5.0)
project(hello)

set (CMAKE_POSITION_INDEPENDENT_CODE ON)

# Abseil requires C++11
set(CMAKE_CXX_STANDARD 11)

# Process Abseil's CMake build system
add_subdirectory(vendor/abseil-cpp)
include_directories(
  /usr/local/include
  ${CMAKE_CURRENT_SOURCE_DIR}/vendor/abseil-cpp
  ${CMAKE_CURRENT_SOURCE_DIR}/src)

add_subdirectory(src)
add_subdirectory(hello)

set(SOURCES absl.cc)
add_library(hello_absl STATIC ${SOURCES})
target_link_libraries(hello_absl absl::flat_hash_map)

#include <string>
#include "absl/container/flat_hash_map.h"

absl::flat_hash_map<int, std::string> fn_return_flat_hash_map(void);

#include "absl.h"

absl::flat_hash_map<int, std::string> fn_return_flat_hash_map(void) {
    absl::flat_hash_map<int, std::string> numbers =
        {{1, "one"}, {2, "two"}, {3, "three"}};
    return numbers;
}

if(SKBUILD)
  message(STATUS "The project is built using scikit-build")
  find_package(PythonExtensions REQUIRED)
  find_package(Cython REQUIRED)

  include_directories(
    /usr/local/include
    ${PYTHON_INCLUDE_DIRS}
    ${CMAKE_CURRENT_SOURCE_DIR}/vendor/abseil-cpp)

  add_cython_target(_hello CXX)
  add_library(_hello MODULE ${_hello})
  target_link_libraries(_hello hello_absl)
  python_extension_module(_hello)

  install(TARGETS _hello LIBRARY DESTINATION hello)
endif()

from libcpp.string cimport string

from absl cimport flat_hash_map

cdef extern from "absl.h":
    cdef flat_hash_map[int, string] fn_return_flat_hash_map() nogil

cpdef dict hello_absl():
    cdef flat_hash_map[int, string] a_map
    with nogil:
      a_map = fn_return_flat_hash_map()
    return {it.first: it.second.decode() for it in a_map}

--- unordered_map.pxd2020-05-10 16:29:28.000000000 +0800
+++ absl.pxd2020-05-10 14:54:27.000000000 +0800
@@ -1,7 +1,7 @@
-from .utility cimport pair
+from libcpp.utility cimport pair
 
-cdef extern from "<unordered_map>" namespace "std" nogil:
-    cdef cppclass unordered_map[T, U]:
+cdef extern from "absl/container/flat_hash_map.h" namespace "absl" nogil:
+    cdef cppclass flat_hash_map[T, U]:
         ctypedef T key_type
         ctypedef U mapped_type
         ctypedef pair[const T, U] value_type
@@ -21,17 +21,17 @@
             pass
         cppclass const_reverse_iterator(reverse_iterator):
             pass
-        unordered_map() except +
-        unordered_map(unordered_map&) except +
-        #unordered_map(key_compare&)
+        flat_hash_map() except +
+        flat_hash_map(flat_hash_map&) except +
+        #flat_hash_map(key_compare&)
         U& operator[](T&)
-        #unordered_map& operator=(unordered_map&)
-        bint operator==(unordered_map&, unordered_map&)
-        bint operator!=(unordered_map&, unordered_map&)
-        bint operator<(unordered_map&, unordered_map&)
-        bint operator>(unordered_map&, unordered_map&)
-        bint operator<=(unordered_map&, unordered_map&)
-        bint operator>=(unordered_map&, unordered_map&)
+        #flat_hash_map& operator=(flat_hash_map&)
+        bint operator==(flat_hash_map&, flat_hash_map&)
+        bint operator!=(flat_hash_map&, flat_hash_map&)
+        bint operator<(flat_hash_map&, flat_hash_map&)
+        bint operator>(flat_hash_map&, flat_hash_map&)
+        bint operator<=(flat_hash_map&, flat_hash_map&)
+        bint operator>=(flat_hash_map&, flat_hash_map&)
         U& at(const T&)
         const U& const_at "at"(const T&)
         iterator begin()
@@ -43,8 +43,8 @@
         const_iterator const_end "end"()
         pair[iterator, iterator] equal_range(T&)
         pair[const_iterator, const_iterator] const_equal_range "equal_range"(const T&)
-        iterator erase(iterator)
-        iterator erase(iterator, iterator)
+        void erase(iterator)
+        void erase(iterator, iterator)
         size_t erase(T&)
         iterator find(T&)
         const_iterator const_find "find"(T&)
@@ -60,7 +60,7 @@
         reverse_iterator rend()
         const_reverse_iterator const_rend "rend"()
         size_t size()
-        void swap(unordered_map&)
+        void swap(flat_hash_map&)
         iterator upper_bound(T&)
         const_iterator const_upper_bound "upper_bound"(T&)
         #value_compare value_comp()

import hello


def test_hello_absl():
    ret = hello.hello_absl()
    assert ret == {1: "one", 2: "two", 3: "three"}

$ pytest -v
test_hello_cython.py::test_hello_absl PASSED

from distutils.core import setup, Extension

module1 = Extension(
    'demo',
    define_macros=[
        ('MAJOR_VERSION', '1'),
        ('MINOR_VERSION', '0')
    ],
    include_dirs=['/usr/local/include'],
    libraries =['tcl83'],
    library_dirs=['/usr/local/lib'],
    sources=['demo.c']
)

setup(
    name='PackageName',
    version='1.0',
    description='This is a demo package',
    author='Martin v. Loewis',
    author_email='martin@v.loewis.de',
    url='https://docs.python.org/extending/building',
    long_description='''
This is really just a demo package.
''',
    ext_modules=[module1]
)

mkdir build
cd build
cmake ..
make

import os
import re
import sys
import platform
import subprocess

from setuptools import setup, Extension
from setuptools.command.build_ext import build_ext
from distutils.version import LooseVersion


class CMakeExtension(Extension):
    def __init__(self, name, sourcedir=''):
        Extension.__init__(self, name, sources=[])
        self.sourcedir = os.path.abspath(sourcedir)


class CMakeBuild(build_ext):
    def run(self):
        try:
            out = subprocess.check_output(['cmake', '--version'])
        except OSError:
            raise RuntimeError("CMake must be installed to build the following extensions: " +
                               ", ".join(e.name for e in self.extensions))

        if platform.system() == "Windows":
            cmake_version = LooseVersion(re.search(r'version\s*([\d.]+)', out.decode()).group(1))
            if cmake_version < '3.1.0':
                raise RuntimeError("CMake >= 3.1.0 is required on Windows")

        for ext in self.extensions:
            self.build_extension(ext)

    def build_extension(self, ext):
        extdir = os.path.abspath(os.path.dirname(self.get_ext_fullpath(ext.name)))
        # required for auto-detection of auxiliary "native" libs
        if not extdir.endswith(os.path.sep):
            extdir += os.path.sep

        cmake_args = ['-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=' + extdir,
                      '-DPYTHON_EXECUTABLE=' + sys.executable]

        cfg = 'Debug' if self.debug else 'Release'
        build_args = ['--config', cfg]

        if platform.system() == "Windows":
            cmake_args += ['-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_{}={}'.format(cfg.upper(), extdir)]
            if sys.maxsize > 2**32:
                cmake_args += ['-A', 'x64']
            build_args += ['--', '/m']
        else:
            cmake_args += ['-DCMAKE_BUILD_TYPE=' + cfg]
            build_args += ['--', '-j2']

        env = os.environ.copy()
        env['CXXFLAGS'] = '{} -DVERSION_INFO=\\"{}\\"'.format(env.get('CXXFLAGS', ''),
                                                              self.distribution.get_version())
        if not os.path.exists(self.build_temp):
            os.makedirs(self.build_temp)
        subprocess.check_call(['cmake', ext.sourcedir] + cmake_args, cwd=self.build_temp, env=env)
        subprocess.check_call(['cmake', '--build', '.'] + build_args, cwd=self.build_temp)

setup(
    name='cmake_example',
    version='0.0.1',
    author='Dean Moldovan',
    author_email='dean0x7d@gmail.com',
    description='A test project using pybind11 and CMake',
    long_description='',
    ext_modules=[CMakeExtension('cmake_example')],
    cmdclass=dict(build_ext=CMakeBuild),
    zip_safe=False,
)

cmake_minimum_required(VERSION 2.8.12)
project(cmake_example)

add_subdirectory(pybind11)
pybind11_add_module(cmake_example src/main.cpp)

import sys

from skbuild import setup

# Require pytest-runner only when running tests
pytest_runner = (['pytest-runner>=2.0,<3dev']
                 if any(arg in sys.argv for arg in ('pytest', 'test'))
                 else [])

setup_requires = pytest_runner

setup(
    name="hello-cpp",
    version="1.2.3",
    description="a minimal example package (cpp version)",
    author='The scikit-build team',
    license="MIT",
    packages=['hello'],
    tests_require=['pytest'],
    setup_requires=setup_requires
)

cmake_minimum_required(VERSION 3.4.0)

project(hello)

find_package(PythonExtensions REQUIRED)

add_library(_hello MODULE hello/_hello.cxx)
python_extension_module(_hello)
install(TARGETS _hello LIBRARY DESTINATION hello)

[build-system]
requires = ["setuptools", "wheel", "scikit-build", "cmake", "ninja"]

class StringField(BaseField):
    def __to_text(self, value):
        return to_text(value)

    converter = __to_text

    def to_xml(self, value):
        value = self.converter(value)
        return f"<{self.name}><![CDATA[{value}]]></{self.name}>"

    @classmethod
    def from_xml(cls, value):
        return value

from wechatpy.replies import TextReply

reply = TextReply(content='text reply', message=msg)
# 或者
reply = TextReply(message=msg)
reply.content = 'text reply'
# 转换成 XML
xml = reply.render()

from wechatpy import WeChatClient

client = WeChatClient('appid', 'secret')
# 发送图片消息
res = client.message.send_image('openid', 'media_id')
# 查询自定义菜单
menu = client.menu.get()

import inspect

from wechatpy.client.api.base import BaseWeChatAPI

def _is_api_endpoint(obj):
    return isinstance(obj, BaseWeChatAPI)

class BaseWeChatClient:
    def __new__(cls, *args, **kwargs):
        self = super().__new__(cls)
        api_endpoints = inspect.getmembers(self, _is_api_endpoint)
        for name, api in api_endpoints:
            api_cls = type(api)
            api = api_cls(self)
            setattr(self, name, api)
        return self

from wechatpy.client.base import BaseWeChatClient
from wechatpy.client.api.base import BaseWeChatAPI


class WeChatMenu(BaseWeChatAPI):
    def get(self):
        # 实现代码省略


class WeChatClient(BaseWeChatClient):
    API_BASE_URL = "https://api.weixin.qq.com/cgi-bin/"
    
    menu = WeChatMenu()

[uwsgi]
chdir = /home/foo/helloworld
module = helloworld.wsgi
processes  = 4
socket = /var/run/uwsgi/app.sock
pidfile = /var/run/uwsgi/app.pid
vacuum = false

master-fifo = /tmp/app.new.fifo
master-fifo = /tmp/app.running.fifo

if-exists = /tmp/app.running.fifo
  hook-accepting1-once = writefifo:/tmp/app.running.fifo q
endif =
hook-accepting1-once = writefifo:/tmp/app.new.fifo 1P

[uwsgi]
chdir = /home/foo/helloworld
module = helloworld.wsgi
processes  = 4
socket = /var/run/uwsgi/app.sock
pidfile = /var/run/uwsgi/app.pid
vacuum = false

master-fifo = /tmp/app.new.fifo
master-fifo = /tmp/app.running.fifo
master-fifo = /tmp/app.quit.fifo

if-exists = /tmp/app.running.fifo
  hook-accepting1-once = writefifo:/tmp/app.running.fifo 2q
endif =
hook-accepting1-once = spinningfifo:/tmp/app.new.fifo 1P

cd /tmp
curl https://raw.githubusercontent.com/blademainer/miwifi-ss/master/miwifi.sh -o miwifi.sh
chmod +x miwifi.sh
sh ./miwifi.sh
rm miwifi.sh

iptables -t nat -N SHADOWSOCKS

iptables -t nat -A SHADOWSOCKS -d YOUR_SS_SERVER_IP -j RETURN

iptables -t nat -A SHADOWSOCKS -d 0.0.0.0/8 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 10.0.0.0/8 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 127.0.0.0/8 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 169.254.0.0/16 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 172.16.0.0/12 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 192.168.0.0/16 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 224.0.0.0/4 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 240.0.0.0/4 -j RETURN

iptables -t nat -A SHADOWSOCKS -p tcp -j REDIRECT --to-ports 1081

iptables -t nat -A PREROUTING -p tcp -j SHADOWSOCKS

/etc/init.d/firewall restart

/etc/init.d/dnsmasq restart