func updateExposeControllerConfig(c *k8sclient.Client, ns string, apiserver string, domain string, mini bool, useLoadBalancer bool) {
// create a populate the exposecontroller config map
cfgms := c.ConfigMaps(ns)
_, err := cfgms.Get(exposecontrollerCM)
if err == nil {
util.Infof("\nRecreating configmap %s \n", exposecontrollerCM)
err = cfgms.Delete(exposecontrollerCM)
if err != nil {
printError("\nError deleting ConfigMap: "+exposecontrollerCM, err)
}
}
apiserverAndPort := apiserver
if !strings.Contains(apiserverAndPort, ":") {
apiserverAndPort = apiserverAndPort + ":8443"
}
domainData := "domain: " + domain + "\n"
exposeData := exposeRule + ": " + defaultExposeRule(c, mini, useLoadBalancer) + "\n"
apiserverData := "apiserver: " + apiserverAndPort + "\n"
configFile := map[string]string{
"config.yml": domainData + exposeData + apiserverData,
}
configMap := kapi.ConfigMap{
ObjectMeta: kapi.ObjectMeta{
Name: exposecontrollerCM,
Labels: map[string]string{
"provider": "fabric8",
},
},
Data: configFile,
}
_, err = cfgms.Create(&configMap)
if err != nil {
printError("Failed to create ConfigMap: "+exposecontrollerCM, err)
}
}
func installTemplates(kc *k8sclient.Client, c *oclient.Client, fac *cmdutil.Factory, v string, templateUrl string, dockerRegistry string, arch string, domain string) error {
ns, _, err := fac.DefaultNamespace()
if err != nil {
util.Fatal("No default namespace")
return err
}
templates := c.Templates(ns)
uri := fmt.Sprintf(templateUrl, v)
util.Infof("Downloading apps from: %v\n", uri)
resp, err := http.Get(uri)
if err != nil {
util.Fatalf("Cannot get fabric8 template to deploy: %v", err)
}
defer resp.Body.Close()
tmpFileName := path.Join(os.TempDir(), "fabric8-template-distros.tar.gz")
t, err := os.OpenFile(tmpFileName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0777)
if err != nil {
return err
}
defer t.Close()
_, err = io.Copy(t, resp.Body)
if err != nil {
return err
}
r, err := zip.OpenReader(tmpFileName)
if err != nil {
return err
}
defer r.Close()
typeOfMaster := util.TypeOfMaster(kc)
for _, f := range r.File {
mode := f.FileHeader.Mode()
if mode.IsDir() {
continue
}
rc, err := f.Open()
if err != nil {
return err
}
defer rc.Close()
jsonData, err := ioutil.ReadAll(rc)
if err != nil {
util.Fatalf("Cannot get fabric8 template to deploy: %v", err)
}
jsonData, err = adaptFabric8ImagesInResourceDescriptor(jsonData, dockerRegistry, arch)
if err != nil {
util.Fatalf("Cannot append docker registry: %v", err)
}
jsonData = replaceDomain(jsonData, domain, ns, typeOfMaster)
var v1tmpl tapiv1.Template
lowerName := strings.ToLower(f.Name)
// if the folder starts with kubernetes/ or openshift/ then lets filter based on the cluster:
if strings.HasPrefix(lowerName, "kubernetes/") && typeOfMaster != util.Kubernetes {
//util.Info("Ignoring as on openshift!")
continue
}
if strings.HasPrefix(lowerName, "openshift/") && typeOfMaster == util.Kubernetes {
//util.Info("Ignoring as on kubernetes!")
continue
}
configMapKeySuffix := ".json"
if strings.HasSuffix(lowerName, ".yml") || strings.HasSuffix(lowerName, ".yaml") {
configMapKeySuffix = ".yml"
err = yaml.Unmarshal(jsonData, &v1tmpl)
} else if strings.HasSuffix(lowerName, ".json") {
err = json.Unmarshal(jsonData, &v1tmpl)
} else {
continue
}
if err != nil {
util.Fatalf("Cannot unmarshall the fabric8 template %s to deploy: %v", f.Name, err)
}
util.Infof("Loading template %s\n", f.Name)
var tmpl tapi.Template
err = api.Scheme.Convert(&v1tmpl, &tmpl)
if err != nil {
util.Fatalf("Cannot get fabric8 template to deploy: %v", err)
return err
}
name := tmpl.ObjectMeta.Name
template := true
if len(name) <= 0 {
template = false
name = f.Name
idx := strings.LastIndex(name, "/")
if idx > 0 {
name = name[idx+1:]
}
idx = strings.Index(name, ".")
if idx > 0 {
name = name[0:idx]
}
}
if typeOfMaster == util.Kubernetes {
appName := name
name = "catalog-" + appName
// lets install ConfigMaps for the templates
// TODO should the name have a prefix?
configmap := api.ConfigMap{
ObjectMeta: api.ObjectMeta{
Name: name,
Namespace: ns,
Labels: map[string]string{
"name": appName,
"provider": "fabric8.io",
"kind": "catalog",
},
},
Data: map[string]string{
name + configMapKeySuffix: string(jsonData),
},
}
configmaps := kc.ConfigMaps(ns)
_, err = configmaps.Get(name)
if err == nil {
err = configmaps.Delete(name)
if err != nil {
util.Errorf("Could not delete configmap %s due to: %v\n", name, err)
}
}
_, err = configmaps.Create(&configmap)
if err != nil {
util.Fatalf("Failed to create configmap %v", err)
return err
}
} else {
if !template {
templateName := name
var v1List v1.List
if configMapKeySuffix == ".json" {
err = json.Unmarshal(jsonData, &v1List)
} else {
err = yaml.Unmarshal(jsonData, &v1List)
}
if err != nil {
util.Fatalf("Cannot unmarshal List %s to deploy. error: %v\ntemplate: %s", templateName, err, string(jsonData))
}
if len(v1List.Items) == 0 {
// lets check if its an RC / ReplicaSet or something
_, groupVersionKind, err := api.Codecs.UniversalDeserializer().Decode(jsonData, nil, nil)
if err != nil {
printResult(templateName, Failure, err)
} else {
kind := groupVersionKind.Kind
util.Infof("Processing resource of kind: %s version: %s\n", kind, groupVersionKind.Version)
if len(kind) <= 0 {
printResult(templateName, Failure, fmt.Errorf("Could not find kind from json %s", string(jsonData)))
} else {
util.Warnf("Cannot yet process kind %s, kind for %s\n", kind, templateName)
continue
}
}
} else {
var kubeList api.List
err = api.Scheme.Convert(&v1List, &kubeList)
if err != nil {
util.Fatalf("Cannot convert %s List to deploy: %v", templateName, err)
}
tmpl = tapi.Template{
ObjectMeta: api.ObjectMeta{
Name: name,
Namespace: ns,
Labels: map[string]string{
"name": name,
"provider": "fabric8.io",
},
},
Objects: kubeList.Items,
}
}
}
// remove newlines from description to avoid breaking `oc get template`
description := tmpl.ObjectMeta.Annotations["description"]
if len(description) > 0 {
tmpl.ObjectMeta.Annotations["description"] = strings.Replace(description, "\n", " ", -1)
}
// lets install the OpenShift templates
_, err = templates.Get(name)
if err == nil {
err = templates.Delete(name)
if err != nil {
util.Errorf("Could not delete template %s due to: %v\n", name, err)
}
}
_, err = templates.Create(&tmpl)
if err != nil {
util.Warnf("Failed to create template %v", err)
return err
}
}
}
return nil
}
func validateConfigMaps(c *k8sclient.Client, f *cmdutil.Factory) (Result, error) {
ns, _, err := f.DefaultNamespace()
if err != nil {
return Failure, err
}
list, err := c.ConfigMaps(ns).List(api.ListOptions{})
if err == nil && list != nil {
return Success, err
}
return Failure, err
}
func deleteConfigMaps(c *k8sclient.Client, ns string, selector labels.Selector) error {
cmps, err := c.ConfigMaps(ns).List(api.ListOptions{LabelSelector: selector})
if err != nil {
return err
}
for _, cm := range cmps.Items {
err := c.ConfigMaps(ns).Delete(cm.Name)
if err != nil {
return errors.Wrap(err, fmt.Sprintf("failed to delete ConfigMap %s", cm.Name))
}
}
return nil
}
// GetConfigMapDetail returns returns detailed information about a config map
func GetConfigMapDetail(client *client.Client, namespace, name string) (*ConfigMapDetail, error) {
log.Printf("Getting details of %s config map in %s namespace", name, namespace)
rawConfigMap, err := client.ConfigMaps(namespace).Get(name)
if err != nil {
return nil, err
}
return getConfigMapDetail(rawConfigMap), nil
}
func installTemplates(kc *k8sclient.Client, c *oclient.Client, fac *cmdutil.Factory, v string, templateUrl string, dockerRegistry string, arch string, domain string) error {
ns, _, err := fac.DefaultNamespace()
if err != nil {
util.Fatal("No default namespace")
return err
}
templates := c.Templates(ns)
util.Infof("Downloading templates for version %v\n", v)
uri := fmt.Sprintf(templateUrl, v)
resp, err := http.Get(uri)
if err != nil {
util.Fatalf("Cannot get fabric8 template to deploy: %v", err)
}
defer resp.Body.Close()
tmpFileName := "/tmp/fabric8-template-distros.tar.gz"
t, err := os.OpenFile(tmpFileName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0777)
if err != nil {
return err
}
defer t.Close()
_, err = io.Copy(t, resp.Body)
if err != nil {
return err
}
r, err := zip.OpenReader(tmpFileName)
if err != nil {
return err
}
defer r.Close()
typeOfMaster := util.TypeOfMaster(kc)
for _, f := range r.File {
mode := f.FileHeader.Mode()
if mode.IsDir() {
continue
}
rc, err := f.Open()
if err != nil {
return err
}
defer rc.Close()
util.Infof("Loading template %s\n", f.Name)
jsonData, err := ioutil.ReadAll(rc)
if err != nil {
util.Fatalf("Cannot get fabric8 template to deploy: %v", err)
}
jsonData, err = adaptFabric8ImagesInResourceDescriptor(jsonData, dockerRegistry, arch)
if err != nil {
util.Fatalf("Cannot append docker registry: %v", err)
}
jsonData = replaceDomain(jsonData, domain, ns, typeOfMaster)
var v1tmpl tapiv1.Template
err = json.Unmarshal(jsonData, &v1tmpl)
if err != nil {
util.Fatalf("Cannot get fabric8 template to deploy: %v", err)
}
var tmpl tapi.Template
err = api.Scheme.Convert(&v1tmpl, &tmpl)
if err != nil {
util.Fatalf("Cannot get fabric8 template to deploy: %v", err)
return err
}
name := tmpl.ObjectMeta.Name
if typeOfMaster == util.Kubernetes {
appName := name
name = "catalog-" + appName
// lets install ConfigMaps for the templates
// TODO should the name have a prefix?
configmap := api.ConfigMap{
ObjectMeta: api.ObjectMeta{
Name: name,
Namespace: ns,
Labels: map[string]string{
"name": appName,
"provider": "fabric8.io",
"kind": "catalog",
},
},
Data: map[string]string{
name + ".json": string(jsonData),
},
}
configmaps := kc.ConfigMaps(ns)
_, err = configmaps.Get(name)
if err == nil {
err = configmaps.Delete(name)
if err != nil {
util.Errorf("Could not delete configmap %s due to: %v\n", name, err)
}
}
_, err = configmaps.Create(&configmap)
if err != nil {
util.Fatalf("Failed to create configmap %v", err)
return err
}
} else {
// lets install the OpenShift templates
_, err = templates.Get(name)
if err == nil {
err = templates.Delete(name)
if err != nil {
util.Errorf("Could not delete template %s due to: %v\n", name, err)
}
}
_, err = templates.Create(&tmpl)
if err != nil {
util.Fatalf("Failed to create template %v", err)
return err
}
}
}
return nil
}
func DoTestConfigMap(t *testing.T, client *client.Client) {
ns := "ns"
cfg := api.ConfigMap{
ObjectMeta: api.ObjectMeta{
Name: "configmap",
Namespace: ns,
},
Data: map[string]string{
"data-1": "value-1",
"data-2": "value-2",
"data-3": "value-3",
},
}
if _, err := client.ConfigMaps(cfg.Namespace).Create(&cfg); err != nil {
t.Errorf("unable to create test configMap: %v", err)
}
defer deleteConfigMapOrErrorf(t, client, cfg.Namespace, cfg.Name)
pod := &api.Pod{
ObjectMeta: api.ObjectMeta{
Name: "XXX",
},
Spec: api.PodSpec{
Containers: []api.Container{
{
Name: "fake-name",
Image: "fakeimage",
Env: []api.EnvVar{
{
Name: "CONFIG_DATA_1",
ValueFrom: &api.EnvVarSource{
ConfigMapKeyRef: &api.ConfigMapKeySelector{
LocalObjectReference: api.LocalObjectReference{
Name: "configmap",
},
Key: "data-1",
},
},
},
{
Name: "CONFIG_DATA_2",
ValueFrom: &api.EnvVarSource{
ConfigMapKeyRef: &api.ConfigMapKeySelector{
LocalObjectReference: api.LocalObjectReference{
Name: "configmap",
},
Key: "data-2",
},
},
}, {
Name: "CONFIG_DATA_3",
ValueFrom: &api.EnvVarSource{
ConfigMapKeyRef: &api.ConfigMapKeySelector{
LocalObjectReference: api.LocalObjectReference{
Name: "configmap",
},
Key: "data-3",
},
},
},
},
},
},
},
}
pod.ObjectMeta.Name = "uses-configmap"
if _, err := client.Pods(ns).Create(pod); err != nil {
t.Errorf("Failed to create pod: %v", err)
}
defer deletePodOrErrorf(t, client, ns, pod.Name)
}
func deleteConfigMapOrErrorf(t *testing.T, c *client.Client, ns, name string) {
if err := c.ConfigMaps(ns).Delete(name); err != nil {
t.Errorf("unable to delete ConfigMap %v: %v", name, err)
}
}
func mapWatchFunc(c *client.Client, ns string) func(options api.ListOptions) (watch.Interface, error) {
return func(options api.ListOptions) (watch.Interface, error) {
return c.ConfigMaps(ns).Watch(options)
}
}
func mapListFunc(c *client.Client, ns string) func(api.ListOptions) (runtime.Object, error) {
return func(opts api.ListOptions) (runtime.Object, error) {
return c.ConfigMaps(ns).List(opts)
}
}
By("Generate event list options")
selector := fields.Set{
"involvedObject.kind": "Node",
"involvedObject.name": node.Name,
"involvedObject.namespace": api.NamespaceAll,
"source": source,
}.AsSelector()
eventListOptions = api.ListOptions{FieldSelector: selector}
By("Create the test log file")
tmpDir = "/tmp/" + name
cmd := fmt.Sprintf("mkdir %s; > %s/%s", tmpDir, tmpDir, logFile)
Expect(framework.IssueSSHCommand(cmd, framework.TestContext.Provider, node)).To(Succeed())
By("Create config map for the node problem detector")
_, err = c.ConfigMaps(ns).Create(&api.ConfigMap{
ObjectMeta: api.ObjectMeta{
Name: configName,
},
Data: map[string]string{configFile: config},
})
Expect(err).NotTo(HaveOccurred())
By("Create the node problem detector")
_, err = c.Pods(ns).Create(&api.Pod{
ObjectMeta: api.ObjectMeta{
Name: name,
},
Spec: api.PodSpec{
NodeName: node.Name,
SecurityContext: &api.PodSecurityContext{HostNetwork: true},
Volumes: []api.Volume{
{
Name: configVolume,
VolumeSource: api.VolumeSource{
func loadTemplateData(ns string, templateName string, c *k8sclient.Client, oc *oclient.Client) ([]byte, string, error) {
typeOfMaster := util.TypeOfMaster(c)
if typeOfMaster == util.Kubernetes {
catalogName := "catalog-" + templateName
configMap, err := c.ConfigMaps(ns).Get(catalogName)
if err != nil {
return nil, "", err
}
for k, v := range configMap.Data {
if strings.LastIndex(k, ".json") >= 0 {
return []byte(v), "json", nil
}
if strings.LastIndex(k, ".yml") >= 0 || strings.LastIndex(k, ".yaml") >= 0 {
return []byte(v), "yaml", nil
}
}
return nil, "", fmt.Errorf("Could not find a key for the catalog %s which ends with `.json` or `.yml`", catalogName)
} else {
template, err := oc.Templates(ns).Get(templateName)
if err != nil {
return nil, "", err
}
data, err := json.Marshal(template)
return data, "json", err
}
return nil, "", nil
}