cloud provider route controller

// startControllers starts the cloud specific controller loops.
func startControllers(c *cloudcontrollerconfig.CompletedConfig, stop <-chan struct{}, cloud cloudprovider.Interface) error {
...
	// If CIDRs should be allocated for pods and set on the CloudProvider, then start the route controller
	if c.ComponentConfig.KubeCloudShared.AllocateNodeCIDRs && c.ComponentConfig.KubeCloudShared.ConfigureCloudRoutes {
    // 这里判断是否实现了 cloud provider route 相关接口
		if routes, ok := cloud.Routes(); !ok {
			glog.Warning("configure-cloud-routes is set, but cloud provider does not support routes. Will not configure cloud provider routes.")
		} else {
			var clusterCIDR *net.IPNet
			if len(strings.TrimSpace(c.ComponentConfig.KubeCloudShared.ClusterCIDR)) != 0 {
				_, clusterCIDR, err = net.ParseCIDR(c.ComponentConfig.KubeCloudShared.ClusterCIDR)
				if err != nil {
					glog.Warningf("Unsuccessful parsing of cluster CIDR %v: %v", c.ComponentConfig.KubeCloudShared.ClusterCIDR, err)
				}
			}

			routeController := routecontroller.New(routes, client("route-controller"), c.SharedInformers.Core().V1().Nodes(), c.ComponentConfig.KubeCloudShared.ClusterName, clusterCIDR)
			go routeController.Run(stop, c.ComponentConfig.KubeCloudShared.RouteReconciliationPeriod.Duration)
  ...
}

func (rc *RouteController) Run(stopCh <-chan struct{}, syncPeriod time.Duration) {
...

   // TODO: If we do just the full Resync every 5 minutes (default value)
   // that means that we may wait up to 5 minutes before even starting
   // creating a route for it. This is bad.
   // We should have a watch on node and if we observe a new node (with CIDR?)
   // trigger reconciliation for that node.
   go wait.NonSlidingUntil(func() {
      if err := rc.reconcileNodeRoutes(); err != nil {
         glog.Errorf("Couldn't reconcile node routes: %v", err)
      }
   }, syncPeriod, stopCh)
...
}

func (rc *RouteController) reconcileNodeRoutes() error {
   routeList, err := rc.routes.ListRoutes(context.TODO(), rc.clusterName)
...
   return rc.reconcile(nodes, routeList)
}

func (rc *RouteController) reconcile(nodes []*v1.Node, routes []*cloudprovider.Route) error {
   // nodeCIDRs maps nodeName->nodeCIDR
   nodeCIDRs := make(map[types.NodeName]string)
   // routeMap maps routeTargetNode->route
   routeMap := make(map[types.NodeName]*cloudprovider.Route)
   for _, route := range routes {
      if route.TargetNode != "" {
         routeMap[route.TargetNode] = route
      }
   }

   wg := sync.WaitGroup{}
   rateLimiter := make(chan struct{}, maxConcurrentRouteCreations)

   for _, node := range nodes {
      // Skip if the node hasn't been assigned a CIDR yet.
      if node.Spec.PodCIDR == "" {
         continue
      }
      nodeName := types.NodeName(node.Name)
      // Check if we have a route for this node w/ the correct CIDR.
      r := routeMap[nodeName]
      if r == nil || r.DestinationCIDR != node.Spec.PodCIDR {
         // If not, create the route.
         route := &cloudprovider.Route{
            TargetNode:      nodeName,
            DestinationCIDR: node.Spec.PodCIDR,
         }
         nameHint := string(node.UID)
         wg.Add(1)
         go func(nodeName types.NodeName, nameHint string, route *cloudprovider.Route) {
            defer wg.Done()
            err := clientretry.RetryOnConflict(updateNetworkConditionBackoff, func() error {
               startTime := time.Now()
               // Ensure that we don't have more than maxConcurrentRouteCreations
               // CreateRoute calls in flight.
               rateLimiter <- struct{}{}
               glog.Infof("Creating route for node %s %s with hint %s, throttled %v", nodeName, route.DestinationCIDR, nameHint, time.Since(startTime))
               err := rc.routes.CreateRoute(context.TODO(), rc.clusterName, nameHint, route)
               <-rateLimiter

               rc.updateNetworkingCondition(nodeName, err == nil)
               if err != nil {
                  msg := fmt.Sprintf("Could not create route %s %s for node %s after %v: %v", nameHint, route.DestinationCIDR, nodeName, time.Since(startTime), err)
                  if rc.recorder != nil {
                     rc.recorder.Eventf(
                        &v1.ObjectReference{
                           Kind:      "Node",
                           Name:      string(nodeName),
                           UID:       types.UID(nodeName),
                           Namespace: "",
                        }, v1.EventTypeWarning, "FailedToCreateRoute", msg)
                  }
                  glog.V(4).Infof(msg)
                  return err
               }
               glog.Infof("Created route for node %s %s with hint %s after %v", nodeName, route.DestinationCIDR, nameHint, time.Now().Sub(startTime))
               return nil
            })
            if err != nil {
               glog.Errorf("Could not create route %s %s for node %s: %v", nameHint, route.DestinationCIDR, nodeName, err)
            }
         }(nodeName, nameHint, route)
      } else {
         // Update condition only if it doesn't reflect the current state.
         _, condition := v1node.GetNodeCondition(&node.Status, v1.NodeNetworkUnavailable)
         if condition == nil || condition.Status != v1.ConditionFalse {
            rc.updateNetworkingCondition(types.NodeName(node.Name), true)
         }
      }
      nodeCIDRs[nodeName] = node.Spec.PodCIDR
   }
...
   wg.Wait()
   return nil
}