Example #1
0
func TestBackendHandleRequest_renewExtend(t *testing.T) {
	secret := &Secret{
		Type:            "foo",
		Renew:           LeaseExtend(0, 0),
		DefaultDuration: 5 * time.Minute,
	}
	b := &Backend{
		Secrets: []*Secret{secret},
	}

	req := logical.RenewRequest("/foo", secret.Response(nil, nil).Secret, nil)
	req.Secret.LeaseIssue = time.Now().UTC()
	req.Secret.LeaseIncrement = 1 * time.Hour
	resp, err := b.HandleRequest(req)
	if err != nil {
		t.Fatalf("err: %s", err)
	}
	if resp == nil || resp.Secret == nil {
		t.Fatal("should have secret")
	}

	if resp.Secret.Lease < 60*time.Minute || resp.Secret.Lease > 70*time.Minute {
		t.Fatalf("bad: %s", resp.Secret.Lease)
	}
}
Example #2
0
func TestBackendHandleRequest_renewExtend(t *testing.T) {
	sysView := logical.StaticSystemView{
		DefaultLeaseTTLVal: 5 * time.Minute,
		MaxLeaseTTLVal:     30 * time.Hour,
	}

	secret := &Secret{
		Type:            "foo",
		Renew:           LeaseExtend(0, 0, sysView),
		DefaultDuration: 5 * time.Minute,
	}
	b := &Backend{
		Secrets: []*Secret{secret},
	}

	req := logical.RenewRequest("/foo", secret.Response(nil, nil).Secret, nil)
	req.Secret.IssueTime = time.Now().UTC()
	req.Secret.Increment = 1 * time.Hour
	resp, err := b.HandleRequest(req)
	if err != nil {
		t.Fatalf("err: %s", err)
	}
	if resp == nil || resp.Secret == nil {
		t.Fatal("should have secret")
	}

	if resp.Secret.TTL < 59*time.Minute || resp.Secret.TTL > 61*time.Minute {
		t.Fatalf("bad: %s", resp.Secret.TTL)
	}
}
Example #3
0
// renewEntry is used to attempt renew of an internal entry
func (m *ExpirationManager) renewEntry(le *leaseEntry, increment time.Duration) (*logical.Response, error) {
	secret := *le.Secret
	secret.LeaseIssue = le.IssueTime
	secret.LeaseIncrement = increment
	secret.LeaseID = ""

	req := logical.RenewRequest(le.Path, &secret, le.Data)
	resp, err := m.router.Route(req)
	if err != nil {
		return nil, fmt.Errorf("failed to renew entry: %v", err)
	}
	return resp, nil
}
Example #4
0
func TestBackendHandleRequest_renew(t *testing.T) {
	var called uint32
	callback := func(*logical.Request, *FieldData) (*logical.Response, error) {
		atomic.AddUint32(&called, 1)
		return nil, nil
	}

	secret := &Secret{
		Type:  "foo",
		Renew: callback,
	}
	b := &Backend{
		Secrets: []*Secret{secret},
	}

	_, err := b.HandleRequest(logical.RenewRequest(
		"/foo", secret.Response(nil, nil).Secret, nil))
	if err != nil {
		t.Fatalf("err: %s", err)
	}
	if v := atomic.LoadUint32(&called); v != 1 {
		t.Fatalf("bad: %#v", v)
	}
}