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 main() {
flag.Parse()
// uses the current context in kubeconfig
config, err := clientcmd.BuildConfigFromFlags("", *kubeconfig)
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)
}
}
// BeforeEach gets a client and makes a namespace.
func (f *Framework) BeforeEach() {
// The fact that we need this feels like a bug in ginkgo.
// https://github.com/onsi/ginkgo/issues/222
f.cleanupHandle = AddCleanupAction(f.AfterEach)
if f.Client == nil {
By("Creating a kubernetes client")
config, err := LoadConfig()
Expect(err).NotTo(HaveOccurred())
config.QPS = f.options.ClientQPS
config.Burst = f.options.ClientBurst
if TestContext.KubeAPIContentType != "" {
config.ContentType = TestContext.KubeAPIContentType
}
c, err := loadClientFromConfig(config)
Expect(err).NotTo(HaveOccurred())
f.Client = c
f.Clientset_1_2, err = release_1_2.NewForConfig(config)
f.Clientset_1_3, err = release_1_3.NewForConfig(config)
Expect(err).NotTo(HaveOccurred())
clientRepoConfig := getClientRepoConfig(config)
f.StagingClient, err = release_1_4.NewForConfig(clientRepoConfig)
Expect(err).NotTo(HaveOccurred())
}
if f.federated {
if f.FederationClient == nil {
By("Creating a federated kubernetes client")
var err error
f.FederationClient, err = LoadFederationClient()
Expect(err).NotTo(HaveOccurred())
}
if f.FederationClientset == nil {
By("Creating an unversioned federation Clientset")
var err error
f.FederationClientset, err = LoadFederationClientset()
Expect(err).NotTo(HaveOccurred())
}
if f.FederationClientset_1_3 == nil {
By("Creating a release 1.3 federation Clientset")
var err error
f.FederationClientset_1_3, err = LoadFederationClientset_1_3()
Expect(err).NotTo(HaveOccurred())
}
if f.FederationClientset_1_4 == nil {
By("Creating a release 1.4 federation Clientset")
var err error
f.FederationClientset_1_4, err = LoadFederationClientset_1_4()
Expect(err).NotTo(HaveOccurred())
}
By("Waiting for federation-apiserver to be ready")
err := WaitForFederationApiserverReady(f.FederationClientset)
Expect(err).NotTo(HaveOccurred())
By("federation-apiserver is ready")
}
By("Building a namespace api object")
namespace, err := f.CreateNamespace(f.BaseName, map[string]string{
"e2e-framework": f.BaseName,
})
Expect(err).NotTo(HaveOccurred())
f.Namespace = namespace
if TestContext.VerifyServiceAccount {
By("Waiting for a default service account to be provisioned in namespace")
err = WaitForDefaultServiceAccountInNamespace(f.Client, namespace.Name)
Expect(err).NotTo(HaveOccurred())
} else {
Logf("Skipping waiting for service account")
}
if TestContext.GatherKubeSystemResourceUsageData != "false" && TestContext.GatherKubeSystemResourceUsageData != "none" {
f.gatherer, err = NewResourceUsageGatherer(f.Client, ResourceGathererOptions{
inKubemark: ProviderIs("kubemark"),
masterOnly: TestContext.GatherKubeSystemResourceUsageData == "master",
})
if err != nil {
Logf("Error while creating NewResourceUsageGatherer: %v", err)
} else {
go f.gatherer.startGatheringData()
}
}
if TestContext.GatherLogsSizes {
f.logsSizeWaitGroup = sync.WaitGroup{}
f.logsSizeWaitGroup.Add(1)
f.logsSizeCloseChannel = make(chan bool)
f.logsSizeVerifier = NewLogsVerifier(f.Client, f.logsSizeCloseChannel)
go func() {
f.logsSizeVerifier.Run()
f.logsSizeWaitGroup.Done()
}()
}
}
func main() {
flag.Parse()
// uses the current context in kubeconfig
config, err := clientcmd.BuildConfigFromFlags("183.131.19.231:8080", *kubeconfig)
if err != nil {
panic(err.Error())
}
// creates the clientset
clientset, err := kubernetes.NewForConfig(config)
if err != nil {
panic(err.Error())
}
/*//创建replicationController
rcTypeMeta := unversioned.TypeMeta{Kind: "ReplicationController", APIVersion: "v1"}
rcObjectMeta := v1.ObjectMeta{
Name: "redis",
Labels: map[string]string{
"name": "redis",
},
}
instanceCnt := int32(2)
rcSpec := v1.ReplicationControllerSpec{
Replicas: &instanceCnt,
Selector: map[string]string{
"name": "redis",
},
Template: &v1.PodTemplateSpec{
v1.ObjectMeta{
Labels: map[string]string{
"name": "redis",
},
},
v1.PodSpec{
Containers: []v1.Container{
v1.Container{
Name: "redis",
Image: "redis",
Ports: []v1.ContainerPort{
v1.ContainerPort{
ContainerPort: 6379,
Protocol: v1.ProtocolTCP,
},
},
Resources: v1.ResourceRequirements{
Requests: v1.ResourceList{
v1.ResourceCPU: resource.MustParse("100m"),
v1.ResourceMemory: resource.MustParse("100Mi"),
},
},
},
},
},
},
}
rc := new(v1.ReplicationController)
rc.TypeMeta = rcTypeMeta
rc.ObjectMeta = rcObjectMeta
rc.Spec = rcSpec
//创建
result, err := clientset.Core().ReplicationControllers("default").Create(rc)
if err != nil {
fmt.Printf("deploy application failed ,the reason is %s", err.Error())
fmt.Println()
}
str, _ := jsonx.ToJson(result)
fmt.Printf("the result is %v", str)
fmt.Println()*/
// err = clientset.Core().ReplicationControllers("default").Delete("redis", &api.DeleteOptions{
// TypeMeta: unversioned.TypeMeta{
// Kind: "ReplicationController",
// APIVersion: "v1",
// },
// OrphanDependents: new(bool),
// })
// if err != nil {
// fmt.Printf("err is %v", err.Error())
// }
// for {
pods, err := clientset.Core().Pods("default").List(api.ListOptions{})
if err != nil {
panic(err.Error())
}
for i := 0; i < len(pods.Items); i++ {
}
fmt.Printf("There are %#v pods in the cluster\n", pods)
// str, _ := jsonx.ToJson(pods.Items)
// fmt.Printf("pods in the cluster is %v \n", str)
// time.Sleep(10 * time.Second)
// }
}