// BuildConfigFromFlags is a helper function that builds configs from a master
// url or a kubeconfig filepath. These are passed in as command line flags for cluster
// components. Warnings should reflect this usage. If neither masterUrl or kubeconfigPath
// are passed in we fallback to inClusterConfig. If inClusterConfig fails, we fallback
// to the default config.
func BuildConfigFromFlags(masterUrl, kubeconfigPath string) (*rest.Config, error) {
if kubeconfigPath == "" && masterUrl == "" {
glog.Warningf("Neither --kubeconfig nor --master was specified. Using the inClusterConfig. This might not work.")
kubeconfig, err := rest.InClusterConfig()
if err == nil {
return kubeconfig, nil
}
glog.Warning("error creating inClusterConfig, falling back to default config: ", err)
}
return NewNonInteractiveDeferredLoadingClientConfig(
&ClientConfigLoadingRules{ExplicitPath: kubeconfigPath},
&ConfigOverrides{ClusterInfo: clientcmdapi.Cluster{Server: masterUrl}}).ClientConfig()
}
func main() {
flag.Parse()
log.Println("[Emmie] is up and running!", time.Now())
// Sanitize docker registry
if *argDockerRegistry != "" {
*argDockerRegistry = fmt.Sprintf("%s/", *argDockerRegistry)
}
// Configure router
router := mux.NewRouter().StrictSlash(true)
router.HandleFunc("/", indexRoute)
router.HandleFunc("/deploy/{namespace}/{branchName}", deployRoute).Methods("POST")
router.HandleFunc("/deploy/{branchName}", deleteRoute).Methods("DELETE")
router.HandleFunc("/deploy", getDeploymentsRoute).Methods("GET")
// Services
// router.HandleFunc("/services/{namespace}/{serviceName}", getServiceRoute).Methods("GET")
// router.HandleFunc("/services/{namespace}/{key}/{value}", getServicesRoute).Methods("GET")
// ReplicationControllers
// router.HandleFunc("/replicationControllers/{namespace}/{rcName}", getReplicationControllerRoute).Methods("GET")
// router.HandleFunc("/replicationControllers/{namespace}/{key}/{value}", getReplicationControllersRoute).Methods("GET")
// Deployments
// router.HandleFunc("/deployments/{namespace}/{deploymentName}", getDeploymentRoute).Methods("GET")
// router.HandleFunc("/deployments/{namespace}/{key}/{value}", getDeploymentsRoute).Methods("GET")
// Version
router.HandleFunc("/version", versionRoute)
// Create k8s client
config, err := rest.InClusterConfig()
//config, err := clientcmd.BuildConfigFromFlags("", *argKubecfgFile)
if err != nil {
panic(err.Error())
}
// creates the clientset
clientset, err := kubernetes.NewForConfig(config)
if err != nil {
panic(err.Error())
}
client = clientset
// Start server
log.Fatal(http.ListenAndServeTLS(fmt.Sprintf(":%d", *argListenPort), "certs/cert.pem", "certs/key.pem", router))
//log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", *argListenPort), router))
}
func main() {
nginx.Start()
cfg, err := rest.InClusterConfig()
if err != nil {
log.Fatalf("Failed to create config: %v", err)
}
kubeClient, err := kubernetes.NewForConfig(cfg)
if err != nil {
log.Fatalf("Failed to create client: %v.", err)
}
rateLimiter := flowcontrol.NewTokenBucketRateLimiter(0.1, 1)
known := &model.RouterConfig{}
// Main loop
for {
rateLimiter.Accept()
routerConfig, err := model.Build(kubeClient)
if err != nil {
log.Printf("Error building model; not modifying certs or configuration: %v.", err)
continue
}
if reflect.DeepEqual(routerConfig, known) {
continue
}
log.Println("INFO: Router configuration has changed in k8s.")
err = nginx.WriteCerts(routerConfig, "/opt/router/ssl")
if err != nil {
log.Printf("Failed to write certs; continuing with existing certs, dhparam, and configuration: %v", err)
continue
}
err = nginx.WriteDHParam(routerConfig, "/opt/router/ssl")
if err != nil {
log.Printf("Failed to write dhparam; continuing with existing dhparam and configuration: %v", err)
continue
}
err = nginx.WriteConfig(routerConfig, "/opt/router/conf/nginx.conf")
if err != nil {
log.Printf("Failed to write new nginx configuration; continuing with existing configuration: %v", err)
continue
}
err = nginx.Reload()
if err != nil {
log.Printf("Failed to reload nginx; continuing with existing configuration: %v", err)
continue
}
known = routerConfig
}
}
func main() {
// creates the in-cluster config
config, err := rest.InClusterConfig()
if err != nil {
panic(err.Error())
}
// creates the clientset
clientset, err := kubernetes.NewForConfig(config)
if err != nil {
panic(err.Error())
}
for {
pods, err := clientset.Core().Pods("").List(api.ListOptions{})
if err != nil {
panic(err.Error())
}
fmt.Printf("There are %d pods in the cluster\n", len(pods.Items))
time.Sleep(10 * time.Second)
}
}
func (inClusterClientConfig) ClientConfig() (*rest.Config, error) {
return rest.InClusterConfig()
}
