Changes Lookup to Get since we don't need it (only Execute does).

2025-01-10 22:06:20 +00:00 · 2015-11-11 12:20:40 -08:00 · 2015-11-11 12:20:40 -08:00 · 7af41edf52
commit 7af41edf52
parent a57d642fa0
3 changed files with 63 additions and 106 deletions
--- a/consul/prepared_query_endpoint.go
+++ b/consul/prepared_query_endpoint.go
@ -181,9 +181,9 @@ func parseDNS(dns *structs.QueryDNSOptions) error {
 	return nil
 }

-// Lookup returns a single prepared query by ID or name.
-func (p *PreparedQuery) Lookup(args *structs.PreparedQuerySpecificRequest, reply *structs.IndexedPreparedQueries) error {
-	if done, err := p.srv.forward("PreparedQuery.Lookup", args, args, reply); done {
+// Get returns a single prepared query by ID.
+func (p *PreparedQuery) Get(args *structs.PreparedQuerySpecificRequest, reply *structs.IndexedPreparedQueries) error {
+	if done, err := p.srv.forward("PreparedQuery.Get", args, args, reply); done {
 		return err
 	}

@ -199,15 +199,15 @@ func (p *PreparedQuery) Lookup(args *structs.PreparedQuerySpecificRequest, reply
 	return p.srv.blockingRPC(
 		&args.QueryOptions,
 		&reply.QueryMeta,
-		state.GetQueryWatch("PreparedQueryLookup"),
+		state.GetQueryWatch("PreparedQueryGet"),
 		func() error {
-			index, query, err := state.PreparedQueryLookup(args.QueryIDOrName)
+			index, query, err := state.PreparedQueryGet(args.QueryID)
 			if err != nil {
 				return err
 			}

 			if (query != nil) && (query.Token != args.Token) && (acl != nil && !acl.QueryList()) {
-				p.srv.logger.Printf("[WARN] consul.prepared_query: Request to lookup prepared query '%s' denied because ACL didn't match ACL used to create the query, and a management token wasn't supplied", args.QueryIDOrName)
+				p.srv.logger.Printf("[WARN] consul.prepared_query: Request to get prepared query '%s' denied because ACL didn't match ACL used to create the query, and a management token wasn't supplied", args.QueryID)
 				return permissionDeniedErr
 			}

--- a/consul/prepared_query_endpoint_test.go
+++ b/consul/prepared_query_endpoint_test.go
@ -103,10 +103,10 @@ func TestPreparedQuery_Apply(t *testing.T) {
 	{
 		req := &structs.PreparedQuerySpecificRequest{
 			Datacenter: "dc1",
-			QueryIDOrName: query.Query.ID,
+			QueryID:    query.Query.ID,
 		}
 		var resp structs.IndexedPreparedQueries
-		if err = msgpackrpc.CallWithCodec(codec, "PreparedQuery.Lookup", req, &resp); err != nil {
+		if err = msgpackrpc.CallWithCodec(codec, "PreparedQuery.Get", req, &resp); err != nil {
 			t.Fatalf("err: %v", err)
 		}

@ -134,10 +134,10 @@ func TestPreparedQuery_Apply(t *testing.T) {
 	{
 		req := &structs.PreparedQuerySpecificRequest{
 			Datacenter: "dc1",
-			QueryIDOrName: query.Query.ID,
+			QueryID:    query.Query.ID,
 		}
 		var resp structs.IndexedPreparedQueries
-		if err = msgpackrpc.CallWithCodec(codec, "PreparedQuery.Lookup", req, &resp); err != nil {
+		if err = msgpackrpc.CallWithCodec(codec, "PreparedQuery.Get", req, &resp); err != nil {
 			t.Fatalf("err: %v", err)
 		}

@ -180,10 +180,10 @@ func TestPreparedQuery_Apply(t *testing.T) {
 	{
 		req := &structs.PreparedQuerySpecificRequest{
 			Datacenter: "dc1",
-			QueryIDOrName: query.Query.ID,
+			QueryID:    query.Query.ID,
 		}
 		var resp structs.IndexedPreparedQueries
-		if err = msgpackrpc.CallWithCodec(codec, "PreparedQuery.Lookup", req, &resp); err != nil {
+		if err = msgpackrpc.CallWithCodec(codec, "PreparedQuery.Get", req, &resp); err != nil {
 			t.Fatalf("err: %v", err)
 		}

@ -289,11 +289,11 @@ func TestPreparedQuery_Apply_ACLDeny(t *testing.T) {
 	{
 		req := &structs.PreparedQuerySpecificRequest{
 			Datacenter:   "dc1",
-			QueryIDOrName: query.Query.ID,
+			QueryID:      query.Query.ID,
 			QueryOptions: structs.QueryOptions{Token: "root"},
 		}
 		var resp structs.IndexedPreparedQueries
-		if err = msgpackrpc.CallWithCodec(codec, "PreparedQuery.Lookup", req, &resp); err != nil {
+		if err = msgpackrpc.CallWithCodec(codec, "PreparedQuery.Get", req, &resp); err != nil {
 			t.Fatalf("err: %v", err)
 		}

@ -358,11 +358,11 @@ func TestPreparedQuery_Apply_ACLDeny(t *testing.T) {
 	{
 		req := &structs.PreparedQuerySpecificRequest{
 			Datacenter:   "dc1",
-			QueryIDOrName: query.Query.ID,
+			QueryID:      query.Query.ID,
 			QueryOptions: structs.QueryOptions{Token: "root"},
 		}
 		var resp structs.IndexedPreparedQueries
-		if err = msgpackrpc.CallWithCodec(codec, "PreparedQuery.Lookup", req, &resp); err != nil {
+		if err = msgpackrpc.CallWithCodec(codec, "PreparedQuery.Get", req, &resp); err != nil {
 			t.Fatalf("err: %v", err)
 		}

@ -386,11 +386,11 @@ func TestPreparedQuery_Apply_ACLDeny(t *testing.T) {
 	{
 		req := &structs.PreparedQuerySpecificRequest{
 			Datacenter:   "dc1",
-			QueryIDOrName: query.Query.ID,
+			QueryID:      query.Query.ID,
 			QueryOptions: structs.QueryOptions{Token: "root"},
 		}
 		var resp structs.IndexedPreparedQueries
-		if err = msgpackrpc.CallWithCodec(codec, "PreparedQuery.Lookup", req, &resp); err != nil {
+		if err = msgpackrpc.CallWithCodec(codec, "PreparedQuery.Get", req, &resp); err != nil {
 			t.Fatalf("err: %v", err)
 		}

@ -419,11 +419,11 @@ func TestPreparedQuery_Apply_ACLDeny(t *testing.T) {
 	{
 		req := &structs.PreparedQuerySpecificRequest{
 			Datacenter:   "dc1",
-			QueryIDOrName: query.Query.ID,
+			QueryID:      query.Query.ID,
 			QueryOptions: structs.QueryOptions{Token: "root"},
 		}
 		var resp structs.IndexedPreparedQueries
-		if err = msgpackrpc.CallWithCodec(codec, "PreparedQuery.Lookup", req, &resp); err != nil {
+		if err = msgpackrpc.CallWithCodec(codec, "PreparedQuery.Get", req, &resp); err != nil {
 			t.Fatalf("err: %v", err)
 		}

@ -455,11 +455,11 @@ func TestPreparedQuery_Apply_ACLDeny(t *testing.T) {
 	{
 		req := &structs.PreparedQuerySpecificRequest{
 			Datacenter:   "dc1",
-			QueryIDOrName: query.Query.ID,
+			QueryID:      query.Query.ID,
 			QueryOptions: structs.QueryOptions{Token: "root"},
 		}
 		var resp structs.IndexedPreparedQueries
-		if err = msgpackrpc.CallWithCodec(codec, "PreparedQuery.Lookup", req, &resp); err != nil {
+		if err = msgpackrpc.CallWithCodec(codec, "PreparedQuery.Get", req, &resp); err != nil {
 			t.Fatalf("err: %v", err)
 		}

@ -487,11 +487,11 @@ func TestPreparedQuery_Apply_ACLDeny(t *testing.T) {
 	{
 		req := &structs.PreparedQuerySpecificRequest{
 			Datacenter:   "dc1",
-			QueryIDOrName: query.Query.ID,
+			QueryID:      query.Query.ID,
 			QueryOptions: structs.QueryOptions{Token: "root"},
 		}
 		var resp structs.IndexedPreparedQueries
-		if err = msgpackrpc.CallWithCodec(codec, "PreparedQuery.Lookup", req, &resp); err != nil {
+		if err = msgpackrpc.CallWithCodec(codec, "PreparedQuery.Get", req, &resp); err != nil {
 			t.Fatalf("err: %v", err)
 		}

@ -611,7 +611,7 @@ func TestPreparedQuery_parseQuery(t *testing.T) {
 	}
 }

-func TestPreparedQuery_Lookup(t *testing.T) {
+func TestPreparedQuery_Get(t *testing.T) {
 	dir1, s1 := testServerWithConfig(t, func(c *Config) {
 		c.ACLDatacenter = "dc1"
 		c.ACLMasterToken = "root"
@ -699,11 +699,11 @@ func TestPreparedQuery_Lookup(t *testing.T) {
 	{
 		req := &structs.PreparedQuerySpecificRequest{
 			Datacenter:   "dc1",
-			QueryIDOrName: query.Query.ID,
+			QueryID:      query.Query.ID,
 			QueryOptions: structs.QueryOptions{Token: token1},
 		}
 		var resp structs.IndexedPreparedQueries
-		if err := msgpackrpc.CallWithCodec(codec, "PreparedQuery.Lookup", req, &resp); err != nil {
+		if err := msgpackrpc.CallWithCodec(codec, "PreparedQuery.Get", req, &resp); err != nil {
 			t.Fatalf("err: %v", err)
 		}

@ -726,11 +726,11 @@ func TestPreparedQuery_Lookup(t *testing.T) {
 	{
 		req := &structs.PreparedQuerySpecificRequest{
 			Datacenter:   "dc1",
-			QueryIDOrName: query.Query.ID,
+			QueryID:      query.Query.ID,
 			QueryOptions: structs.QueryOptions{Token: token2},
 		}
 		var resp structs.IndexedPreparedQueries
-		err := msgpackrpc.CallWithCodec(codec, "PreparedQuery.Lookup", req, &resp)
+		err := msgpackrpc.CallWithCodec(codec, "PreparedQuery.Get", req, &resp)
 		if err == nil || !strings.Contains(err.Error(), permissionDenied) {
 			t.Fatalf("bad: %v", err)
 		}
@ -744,11 +744,11 @@ func TestPreparedQuery_Lookup(t *testing.T) {
 	{
 		req := &structs.PreparedQuerySpecificRequest{
 			Datacenter:   "dc1",
-			QueryIDOrName: query.Query.ID,
+			QueryID:      query.Query.ID,
 			QueryOptions: structs.QueryOptions{Token: ""},
 		}
 		var resp structs.IndexedPreparedQueries
-		err := msgpackrpc.CallWithCodec(codec, "PreparedQuery.Lookup", req, &resp)
+		err := msgpackrpc.CallWithCodec(codec, "PreparedQuery.Get", req, &resp)
 		if err == nil || !strings.Contains(err.Error(), permissionDenied) {
 			t.Fatalf("bad: %v", err)
 		}
@ -762,11 +762,11 @@ func TestPreparedQuery_Lookup(t *testing.T) {
 	{
 		req := &structs.PreparedQuerySpecificRequest{
 			Datacenter:   "dc1",
-			QueryIDOrName: query.Query.ID,
+			QueryID:      query.Query.ID,
 			QueryOptions: structs.QueryOptions{Token: "root"},
 		}
 		var resp structs.IndexedPreparedQueries
-		if err := msgpackrpc.CallWithCodec(codec, "PreparedQuery.Lookup", req, &resp); err != nil {
+		if err := msgpackrpc.CallWithCodec(codec, "PreparedQuery.Get", req, &resp); err != nil {
 			t.Fatalf("err: %v", err)
 		}

@ -783,57 +783,15 @@ func TestPreparedQuery_Lookup(t *testing.T) {
 		}
 	}

-	// Try a lookup by name instead of ID.
+	// Try to get an unknown ID.
 	{
 		req := &structs.PreparedQuerySpecificRequest{
 			Datacenter:   "dc1",
-			QueryIDOrName: query.Query.Name,
+			QueryID:      generateUUID(),
 			QueryOptions: structs.QueryOptions{Token: token1},
 		}
 		var resp structs.IndexedPreparedQueries
-		if err := msgpackrpc.CallWithCodec(codec, "PreparedQuery.Lookup", req, &resp); err != nil {
-			t.Fatalf("err: %v", err)
-		}
-
-		if len(resp.Queries) != 1 {
-			t.Fatalf("bad: %v", resp)
-		}
-		actual := resp.Queries[0]
-		if resp.Index != actual.ModifyIndex {
-			t.Fatalf("bad index: %d", resp.Index)
-		}
-		actual.CreateIndex, actual.ModifyIndex = 0, 0
-		if !reflect.DeepEqual(actual, query.Query) {
-			t.Fatalf("bad: %v", actual)
-		}
-	}
-
-	// Try to lookup an unknown ID.
-	{
-		req := &structs.PreparedQuerySpecificRequest{
-			Datacenter:    "dc1",
-			QueryIDOrName: generateUUID(),
-			QueryOptions:  structs.QueryOptions{Token: token1},
-		}
-		var resp structs.IndexedPreparedQueries
-		if err := msgpackrpc.CallWithCodec(codec, "PreparedQuery.Lookup", req, &resp); err != nil {
-			t.Fatalf("err: %v", err)
-		}
-
-		if len(resp.Queries) != 0 {
-			t.Fatalf("bad: %v", resp)
-		}
-	}
-
-	// Try to lookup an unknown name.
-	{
-		req := &structs.PreparedQuerySpecificRequest{
-			Datacenter:    "dc1",
-			QueryIDOrName: "nope",
-			QueryOptions:  structs.QueryOptions{Token: token1},
-		}
-		var resp structs.IndexedPreparedQueries
-		if err := msgpackrpc.CallWithCodec(codec, "PreparedQuery.Lookup", req, &resp); err != nil {
+		if err := msgpackrpc.CallWithCodec(codec, "PreparedQuery.Get", req, &resp); err != nil {
 			t.Fatalf("err: %v", err)
 		}

--- a/consul/structs/prepared_query.go
+++ b/consul/structs/prepared_query.go
@ -115,9 +115,8 @@ type PreparedQuerySpecificRequest struct {
 	// Datacenter is the target this request is intended for.
 	Datacenter string

-	// QueryIDOrName is the ID of a query _or_ the name of one, either can
-	// be provided.
-	QueryIDOrName string
+	// QueryID is the ID of a query.
+	QueryID string

 	// QueryOptions (unfortunately named here) controls the consistency
 	// settings for the query lookup itself, as well as the service lookups.