Beispiel #1
0
func TestKontrolMultiKey(t *testing.T) {
	if storage := os.Getenv("KONTROL_STORAGE"); storage != "postgres" {
		t.Skip("%q storage does not currently implement soft key pair deletes", storage)
	}

	i := uuid.NewV4()
	secondID := i.String()

	// add so we can use it as key
	if err := kon.AddKeyPair(secondID, testkeys.PublicSecond, testkeys.PrivateSecond); err != nil {
		t.Fatal(err)
	}

	// Start mathworker
	mathKite := kite.New("mathworker2", "2.0.0")
	mathKite.Config = conf.Config.Copy()
	mathKite.Config.Port = 6162
	mathKite.HandleFunc("square", Square)
	go mathKite.Run()
	<-mathKite.ServerReadyNotify()
	defer mathKite.Close()

	go mathKite.RegisterForever(&url.URL{Scheme: "http", Host: "127.0.0.1:" + strconv.Itoa(mathKite.Config.Port), Path: "/kite"})
	<-mathKite.KontrolReadyNotify()

	// exp3 kite is the mathworker client. However it uses a different public
	// key
	exp3Kite := kite.New("exp3", "0.0.1")
	exp3Kite.Config = conf.Config.Copy()
	exp3Kite.Config.KiteKey = testutil.NewKiteKeyWithKeyPair(testkeys.PrivateSecond, testkeys.PublicSecond).Raw
	exp3Kite.Config.KontrolKey = testkeys.PublicSecond
	defer exp3Kite.Close()

	query := &protocol.KontrolQuery{
		Username:    exp3Kite.Kite().Username,
		Environment: exp3Kite.Kite().Environment,
		Name:        "mathworker2",
		Version:     "2.0.0",
	}

	// exp3 queries for mathkite
	kites, err := exp3Kite.GetKites(query)
	if err != nil {
		t.Fatal(err)
	}
	defer klose(kites)

	if len(kites) == 0 {
		t.Fatal("No mathworker available")
	}

	// exp3 connectes to mathworker
	remoteMathWorker := kites[0]
	err = remoteMathWorker.Dial()
	if err != nil {
		t.Fatal("Cannot connect to remote mathworker", err)
	}

	// Test Kontrol.GetToken
	// TODO(rjeczalik): rework test to not touch Kontrol internals
	kon.tokenCacheMu.Lock()
	kon.tokenCache = make(map[string]string) // empty it
	kon.tokenCacheMu.Unlock()

	newToken, err := exp3Kite.GetToken(&remoteMathWorker.Kite)
	if err != nil {
		t.Error(err)
	}

	if remoteMathWorker.Auth.Key == newToken {
		t.Errorf("Token renew failed. Tokens should be different after renew")
	}

	// Run "square" method
	response, err := remoteMathWorker.TellWithTimeout("square", 4*time.Second, 2)
	if err != nil {
		t.Fatal(err)
	}

	var result int
	err = response.Unmarshal(&result)
	if err != nil {
		t.Fatal(err)
	}

	// Result must be "4"
	if result != 4 {
		t.Fatalf("Invalid result: %d", result)
	}

	// now invalidate the second key
	log.Printf("Invalidating %s\n", secondID)
	if err := kon.DeleteKeyPair(secondID, ""); err != nil {
		t.Fatal(err)
	}

	// try to get a new key, this should replace exp3Kite.Config.KontrolKey
	// with the new (in our case because PublicSecond is invalidated, it's
	// going to use Public (the first key). Also it should return the new Key.
	publicKey, err := exp3Kite.GetKey()
	if err != nil {
		t.Fatal(err)
	}

	if publicKey != testkeys.Public {
		t.Errorf("Key renew failed\n\twant:%s\n\tgot :%s\n", testkeys.Public, publicKey)
	}

	if exp3Kite.Config.KontrolKey != publicKey {
		t.Errorf("Key renew should replace config.KontrolKey\n\twant:%s\n\tgot :%s\n",
			testkeys.Public, publicKey)
	}
}
Beispiel #2
0
func (cfg *Config) setDefaults() {
	if cfg.TopDir == "" {
		p, err := exec.Command("git", "rev-parse", "--show-toplevel").Output()
		if err != nil {
			cfg.Log.Warning("unable to get git top dir:", err)
		} else {
			cfg.TopDir = string(bytes.TrimSpace(p))
		}
	}

	if cfg.DockerHost == "" {
		if u, err := url.Parse(os.Getenv("DOCKER_HOST")); err == nil {
			if host, _, err := net.SplitHostPort(u.Host); err == nil {
				cfg.DockerHost = host
			} else {
				cfg.DockerHost = u.Host
			}
		}
	}

	if cfg.Username == "" {
		u, err := user.Current()
		if err == nil {
			cfg.Username = u.Username
		}
	}

	if cfg.KontrolPrivate == "" {
		cfg.KontrolPrivate = filepath.Join(cfg.TopDir, "certs", "test_kontrol_rsa_private.pem")
		p, err := ioutil.ReadFile(cfg.KontrolPrivate)
		if err == nil {
			cfg.pemPrivate = string(p)
		}
	}

	if cfg.KontrolPublic == "" {
		cfg.KontrolPublic = filepath.Join(cfg.TopDir, "certs", "test_kontrol_rsa_public.pem")
		p, err := ioutil.ReadFile(cfg.KontrolPublic)
		if err == nil {
			cfg.pemPublic = string(p)
		}
	}

	if cfg.pemPrivate == "" {
		cfg.pemPrivate = testkeys.Private
	}

	if cfg.pemPublic == "" {
		cfg.pemPublic = testkeys.Public
	}

	if cfg.Kontrol.KontrolURL == "" {
		cfg.Kontrol = config.Config{
			Port:        4000,
			Username:    "******",
			Environment: "dev",
			Region:      "dev",
			KontrolUser: "******",
			KontrolKey:  cfg.pemPublic,
			KiteKey:     testutil.NewKiteKeyWithKeyPair(cfg.pemPrivate, cfg.pemPublic).Raw,
			KontrolURL:  "http://localhost:4000/kite",
		}
	}

	if cfg.Postgres == (kontrol.PostgresConfig{}) {
		cfg.Postgres = kontrol.PostgresConfig{
			Host:           cfg.DockerHost,
			Port:           5432,
			Username:       "******",
			Password:       "******",
			DBName:         "social",
			ConnectTimeout: 20,
		}
	}

	if cfg.HostedZone == "" {
		cfg.HostedZone = "dev.koding.io"
	}
}