// CreateBGPNeighbor adds a new BGP neigbhor to a BGP instance in the BIG-IP system.
435753
func (b *BigIP) CreateBGPNeighbor(instance, name string, remoteAS int) error {
	config := &BGPNeighbor{
		Name:     name,
		RemoteAS: remoteAS,
	}

	return b.post(config, uriNet, uriRouting, uriBGP, instance, uriNeighbor)
}
67005
func NewBGP(socket string, asn uint32) *BGP {
	if socket == "" {
		socket = BGPSocketPath
	}
	return &BGP{
		vty: NewVTY(socket),
		asn: asn,
	}
}
88250
func (o *Enterprise) CreateBGPProfile(child *BGPProfile) *bambou.Error {

	return bambou.CurrentSession().CreateChild(o, child)
}
1144570
func (b *BigIP) CreateNodeAdv(name, address, rateLimit string, connectionLimit, dynamicRatio int, monitor, state string) error {
	config := &Node{
		Name:            name,
		Address:         address,
		RateLimit:       rateLimit,
		ConnectionLimit: connectionLimit,
		DynamicRatio:    dynamicRatio,
		Monitor:         monitor,
		State:           state,
	}
	return b.post(config, uriLtm, uriNode)
}
31737
func CreateNetServer(address string) (*NetServer, error) {
	listener, err := net.Listen("tcp", address)
	if err != nil {
		return nil, err
	}

	return NewNetServer(listener), nil
}
28988
func (s *LoadBalancerService) NewCreateGlobalLoadBalancerRuleParams(gslbdomainname string, gslbservicetype string, name string, regionid int) *CreateGlobalLoadBalancerRuleParams {
	p := &CreateGlobalLoadBalancerRuleParams{}
	p.p = make(map[string]interface{})
	p.p["gslbdomainname"] = gslbdomainname
	p.p["gslbservicetype"] = gslbservicetype
	p.p["name"] = name
	p.p["regionid"] = regionid
	return p
}
686987
func createDB(db *sql.DB) error {
	_, err := db.Exec(`
		CREATE EXTENSION IF NOT EXISTS postgis;
		CREATE TABLE IF NOT EXISTS waypoints (
			id SERIAL PRIMARY KEY,
			name TEXT NOT NULL,
			geom geometry(POINT, 4326) NOT NULL
		);
	`)
	return err
}
1191591
func newBGPManager(engine *Engine, interval time.Duration) *bgpManager {
	return &bgpManager{engine: engine, updateInterval: interval}
}
548154
func (b *BigIP) CreateInternalDataGroup(name string, datatype string) error {
	config := &DataGroup{
		Name: name,
		Type: datatype,
	}

	return b.post(config, uriLtm, uriDatagroup, uriInternal)
}
17898
func (s *PortableIPService) NewCreatePortableIpRangeParams(endip string, gateway string, netmask string, regionid int, startip string) *CreatePortableIpRangeParams {
	p := &CreatePortableIpRangeParams{}
	p.p = make(map[string]interface{})
	p.p["endip"] = endip
	p.p["gateway"] = gateway
	p.p["netmask"] = netmask
	p.p["regionid"] = regionid
	p.p["startip"] = startip
	return p
}
96252
func (s *SeesawECU) BGPNeighbors(ctx *ipc.Context, reply *quagga.Neighbors) error {
	s.trace("BGPNeighbors", ctx)

	authConn, err := s.ecu.authConnect(ctx)
	if err != nil {
		return err
	}
	defer authConn.Close()

	neighbors, err := authConn.BGPNeighbors()
	if err != nil {
		return err
	}

	if reply != nil {
		reply.Neighbors = neighbors
	}
	return nil
}
16095
func (sw *OvsSwitch) AddBgp(hostname string, routerIP string,
	As string, neighborAs, neighbor string) error {
	if sw.netType == "vlan" && sw.ofnetAgent != nil {
		err := sw.ofnetAgent.AddBgp(routerIP, As, neighborAs, neighbor)
		if err != nil {
			log.Errorf("Error adding BGP server")
			return err
		}
	}

	return nil
}
727854
func (b *BigIP) BGPInstances() (*BGPInstances, error) {
	var bgpInstances BGPInstances
	err, _ := b.getForEntity(&bgpInstances, uriNet, uriRouting, uriBGP)
	if err != nil {
		return nil, err
	}

	return &bgpInstances, nil
}
1018526
func (d *FakeNetEpDriver) CreateHostAccPort(id, a string, nw int) (string, error) {
	return "", core.Errorf("Not implemented")
}
495607
func (api *API) AddNeighbors(uris ...string) (int64, error) {
	if err := Validate(ValidateURIs(uris...), ValidateNonEmptyStrings(ErrInvalidURI, uris...)); err != nil {
		return 0, err
	}
	cmd := &AddNeighborsCommand{Command: Command{AddNeighborsCmd}, URIs: uris}
	rsp := &AddNeighborsResponse{}
	if err := api.provider.Send(cmd, rsp); err != nil {
		return 0, err
	}
	return rsp.AddedNeighbors, nil
}
1247552
func (o *RedundancyGroup) CreateIngressProfile(child *IngressProfile) *bambou.Error {

	return bambou.CurrentSession().CreateChild(o, child)
}
1162325
func (o *IKEGateway) CreateIKESubnet(child *IKESubnet) *bambou.Error {

	return bambou.CurrentSession().CreateChild(o, child)
}