技术分享 | OpenShift网络之SDN_重启openshift sdn

// Send a CNI request to  the CNI server via JSON + HTTP over a root-owned unix socket,

// and return the result

func (p *cniPlugin) doCNI(url string, req  *cniserver.CNIRequest) ([]byte, error) {

    data, err := json.Marshal(req)

    if err != nil {

        returnnil, fmt.Errorf("failed to marshal  CNI request %v: %v", req, err)

    }

    client := &http.Client{

        Transport: &http.Transport{

            Dial: func(proto, addr string) (net.Conn, error) {

                return net.Dial("unix", p.socketPath)

            },

        },

    }

    varresp *http.Response

    err = p.hostNS.Do(func(ns.NetNS) error {

        resp, err = client.Post(url, "application/json", bytes.NewReader(data))

        return err

    })

    if err != nil {

        returnnil, fmt.Errorf("failed to send CNI  request: %v", err)

    }

    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)

    if err != nil {

        returnnil, fmt.Errorf("failed to read CNI  result: %v", err)

    }

    if resp.StatusCode != 200 {

        returnnil, fmt.Errorf("CNI request failed  with status %v: '%s'", resp.StatusCode, string(body))

    }

    return body, nil

}

// Send the ADD command  environment and config to the CNI server, returning

// the IPAM result to  the caller

func (p *cniPlugin) doCNIServerAdd(req *cniserver.CNIRequest,  hostVeth string) (types.Result, error) {

    req.HostVeth = hostVeth

    body, err := p.doCNI("http://dummy/", req)

    if err != nil {

        returnnil, err

    }

    // We currently expect CNI version 0.2.0  results, because that's the

    // CNIVersion we pass in our config JSON

    result, err := types020.NewResult(body)

    if err != nil {

        returnnil, fmt.Errorf("failed to  unmarshal response '%s': %v", string(body), err)

    }

    return result, nil

}

.... 

func (p *cniPlugin) CmdDel(args *skel.CmdArgs) error {

    _, err := p.doCNI("http://dummy/", newCNIRequest(args))

    return err

}

// Start the CNI server  and start processing requests from it

func (m *podManager) Start(rundir string, localSubnetCIDR string, clusterNetworks  []common.ClusterNetwork, serviceNetworkCIDR string) error {

    if m.enableHostports {

        iptInterface := utiliptables.New(utilexec.New(), utildbus.New(),  utiliptables.ProtocolIpv4)

        m.hostportSyncer = kubehostport.NewHostportSyncer(iptInterface)

    }

    varerrerror

    ifm.ipamConfig, err = getIPAMConfig(clusterNetworks, localSubnetCIDR); err != nil {

        return err

    }

    go m.processCNIRequests()

    m.cniServer = cniserver.NewCNIServer(rundir,  &cniserver.Config{MTU: m.mtu, ServiceNetworkCIDR: serviceNetworkCIDR})

    return m.cniServer.Start(m.handleCNIRequest)

}

//  Create and return a new CNIServer object which will listen on a socket in the  given path

funcNewCNIServer(rundir string, config *Config)  *CNIServer {

    router := mux.NewRouter()

    s := &CNIServer{

        Server: http.Server{

            Handler: router,

        },

        rundir: rundir,

        config: config,