all: implement sub command to remove caches by domain name

The "caches" command accept second sub command "remove" that accept
single domain name to be removed from caches.

This changes affect the HTTP API for caches delete to return the removed
answer on the response data.

8 files changed, 82 insertions, 9 deletions

diff --git a/_doc/resolver.1.gz b/_doc/resolver.1.gz
index 29fe89c..d1343ca 100644
--- a/_doc/resolver.1.gz
+++ b/_doc/resolver.1.gz
diff --git a/_doc/resolver.adoc b/_doc/resolver.adoc
index d529394..cee9158 100644
--- a/_doc/resolver.adoc
+++ b/_doc/resolver.adoc
@@ -108,6 +108,12 @@ Search the domain name in rescached caches.
 This command can also be used to inspect each DNS message on the caches.
 --
 
+caches remove <string>::
++
+--
+Remove the domain name from rescached caches.
+--
+
 
 == EXIT STATUS
 
diff --git a/client.go b/client.go
index ecf6e62..289f031 100644
--- a/client.go
+++ b/client.go
@@ -60,6 +60,36 @@ func (cl *Client) Caches() (answers []*dns.Answer, err error) {
 	return answers, nil
 }
 
+func (cl *Client) CachesRemove(q string) (listAnswer []*dns.Answer, err error) {
+	var (
+		logp   = "CachesRemove"
+		params = url.Values{}
+		res    = libhttp.EndpointResponse{
+			Data: &listAnswer,
+		}
+
+		resb []byte
+	)
+
+	params.Set(paramNameName, q)
+
+	_, resb, err = cl.Delete(apiCaches, nil, params)
+	if err != nil {
+		return nil, fmt.Errorf("%s: %w", logp, err)
+	}
+
+	err = json.Unmarshal(resb, &res)
+	if err != nil {
+		return nil, fmt.Errorf("%s: %w", logp, err)
+	}
+
+	if res.Code != http.StatusOK {
+		return nil, fmt.Errorf("%s: %d %s", logp, res.Code, res.Message)
+	}
+
+	return listAnswer, nil
+}
+
 // CachesSearch search the answer in caches by its domain name and return it
 // as DNS message.
 func (cl *Client) CachesSearch(q string) (listMsg []*dns.Message, err error) {
@@ -70,15 +100,12 @@ func (cl *Client) CachesSearch(q string) (listMsg []*dns.Message, err error) {
 			Data: &listMsg,
 		}
 
-		path string
 		resb []byte
 	)
 
 	params.Set(paramNameQuery, q)
 
-	path = apiCachesSearch + "?" + params.Encode()
-	fmt.Printf("%s: path: %s\n", logp, path)
-	_, resb, err = cl.Get(path, nil, nil)
+	_, resb, err = cl.Get(apiCachesSearch, nil, params)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
diff --git a/cmd/resolver/main.go b/cmd/resolver/main.go
index 322ef85..0be5375 100644
--- a/cmd/resolver/main.go
+++ b/cmd/resolver/main.go
@@ -19,6 +19,7 @@ const (
 	cmdQuery  = "query"
 
 	subCmdSearch = "search"
+	subCmdRemove = "remove"
 )
 
 func main() {
@@ -63,12 +64,23 @@ func main() {
 
 		subCmd = strings.ToLower(args[0])
 		switch subCmd {
+		case subCmdRemove:
+			args = args[1:]
+			if len(args) == 0 {
+				log.Fatalf("resolver: %s %s: missing argument", rsol.cmd, subCmd)
+			}
+			rsol.doCmdCachesRemove(args[0])
+
 		case subCmdSearch:
 			args = args[1:]
 			if len(args) == 0 {
 				log.Fatalf("resolver: %s %s: missing argument", rsol.cmd, subCmd)
 			}
 			rsol.doCmdCachesSearch(args[0])
+
+		default:
+			log.Printf("resolver: %s: unknown sub command: %s", rsol.cmd, subCmd)
+			os.Exit(2)
 		}
 
 	case cmdQuery:
@@ -148,6 +160,10 @@ caches search <string>
 	This command can also be used to inspect each DNS message on the
 	caches.
 
+caches remove <string>
+
+	Remove the domain name from rescached caches.
+
 
 ==  Examples
 
diff --git a/cmd/resolver/resolver.go b/cmd/resolver/resolver.go
index 5ba632f..8804851 100644
--- a/cmd/resolver/resolver.go
+++ b/cmd/resolver/resolver.go
@@ -61,6 +61,28 @@ func (rsol *resolver) doCmdCaches() {
 	printAnswers(answers)
 }
 
+// doCmdCachesRemove remove an answer from caches by domain name.
+func (rsol *resolver) doCmdCachesRemove(q string) {
+	var (
+		resc = rsol.newRescachedClient()
+
+		listAnswer []*dns.Answer
+		err        error
+	)
+
+	listAnswer, err = resc.CachesRemove(q)
+	if err != nil {
+		log.Printf("resolver: caches: %s", err)
+		return
+	}
+
+	fmt.Printf("Total answer removed: %d\n", len(listAnswer))
+	if len(listAnswer) == 0 {
+		return
+	}
+	printAnswers(listAnswer)
+}
+
 // doCmdCachesSearch call the rescached HTTP API to search the caches by
 // domain name.
 func (rsol *resolver) doCmdCachesSearch(q string) {
diff --git a/go.mod b/go.mod
index 6e205b7..800804a 100644
--- a/go.mod
+++ b/go.mod
@@ -5,6 +5,6 @@ module github.com/shuLhan/rescached-go/v4
 
 go 1.16
 
-require github.com/shuLhan/share v0.36.1-0.20220411183137-8422dd7cdee8
+require github.com/shuLhan/share v0.36.1-0.20220414184434-86c787c31de4
 
 //replace github.com/shuLhan/share => ../share
diff --git a/go.sum b/go.sum
index 21e8c16..5c8bbb6 100644
--- a/go.sum
+++ b/go.sum
@@ -1,5 +1,5 @@
-github.com/shuLhan/share v0.36.1-0.20220411183137-8422dd7cdee8 h1:37XdJj5KXgwLSy0TmnWjo29Ez8ze50T7lsh0wcs7ROA=
-github.com/shuLhan/share v0.36.1-0.20220411183137-8422dd7cdee8/go.mod h1:laKGR1DNboj8+INRIC9VFYRiVEu/IIjrLurUmTHXkw0=
+github.com/shuLhan/share v0.36.1-0.20220414184434-86c787c31de4 h1:jcfsLdh6zvuRraYyV1t7SGZ9e1x/HJIzAq35itNWh7c=
+github.com/shuLhan/share v0.36.1-0.20220414184434-86c787c31de4/go.mod h1:laKGR1DNboj8+INRIC9VFYRiVEu/IIjrLurUmTHXkw0=
 golang.org/x/crypto v0.0.0-20220131195533-30dcbda58838/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd h1:O7DYs+zxREGLKzKoMQrtrEacpb0ZVXA5rIwylE2Xchk=
diff --git a/httpd.go b/httpd.go
index d5cb8de..6f4a234 100644
--- a/httpd.go
+++ b/httpd.go
@@ -291,6 +291,8 @@ func (srv *Server) httpdAPIDeleteCaches(epr *libhttp.EndpointRequest) (resBody [
 	var (
 		res = libhttp.EndpointResponse{}
 		q   = epr.HttpRequest.Form.Get(paramNameName)
+
+		answers []*dns.Answer
 	)
 
 	if len(q) == 0 {
@@ -299,10 +301,10 @@ func (srv *Server) httpdAPIDeleteCaches(epr *libhttp.EndpointRequest) (resBody [
 		return nil, &res
 	}
 
-	srv.dns.RemoveCachesByNames([]string{q})
+	answers = srv.dns.RemoveCachesByNames([]string{q})
 
 	res.Code = http.StatusOK
-	res.Message = fmt.Sprintf("%q has been removed from caches", q)
+	res.Data = answers
 
 	return json.Marshal(&res)
 }