Use HTTP verbs for config api instead of separate urls

```
// Get all the configs since empty property passed
$ curl -X GET --unix-socket ~/.crc/crc-http.sock http:/c/api/config

// Get cpus property
$ curl -X GET --unix-socket ~/.crc/crc-http.sock http:/c/api/config?cpus
{"Success":true,"Error":"","Configs":{"cpus":5}}

// Delete cpu property
$ curl -X DELETE -d '{"properties":["cpus"]}' --unix-socket ~/.crc/crc-http.sock http:/c/api/config
{"Success":true,"Error":"","Properties":["cpus"]}

$ curl -X GET --unix-socket ~/.crc/crc-http.sock http:/c/api/config?cpus
{"Success":true,"Error":"","Configs":{"cpus":4}}

// Update cpu propery
$ curl -X POST -d '{"properties":{"cpus":10}}' --unix-socket ~/.crc/crc-http.sock http:/c/api/config
{"Success":true,"Error":"","Properties":["cpus"]}

$ curl -X GET --unix-socket ~/.crc/crc-http.sock http:/c/api/config?cpus
{"Success":true,"Error":"","Configs":{"cpus":10}}
```

pkg/crc/api/api_http.go

@@ -29,12 +29,9 @@ func NewMux(config crcConfig.Storage, machine machine.Client, logger Logger, tel
 
 	server.GET("/webconsoleurl", handler.GetWebconsoleInfo)
 
-	server.GET("/config/set", handler.SetConfig)
-	server.GET("/config/get", handler.GetConfig)
-	server.GET("/config/unset", handler.UnsetConfig)
-	server.POST("/config/set", handler.SetConfig)
-	server.POST("/config/get", handler.GetConfig)
-	server.POST("/config/unset", handler.UnsetConfig)
+	server.GET("/config", handler.GetConfig)
+	server.POST("/config", handler.SetConfig)
+	server.DELETE("/config", handler.UnsetConfig)
 
 	server.GET("/logs", handler.Logs)
 

pkg/crc/api/api_http_test.go

@@ -126,6 +126,88 @@ func TestHTTPApi(t *testing.T) {
 		},
 		configSetResult,
 	)
+	// Get the cpus config again after setting it to make sure it is set
+	// properly.
+	configGetAfterSetResult, err := client.GetConfig([]string{"cpus"})
+	assert.NoError(t, err)
+	assert.Equal(
+		t,
+		apiClient.GetConfigResult{
+			Success: true,
+			Error:   "",
+			Configs: map[string]interface{}{
+				"cpus": float64(5),
+			},
+		},
+		configGetAfterSetResult,
+	)
+
+	configUnsetResult, err := client.UnsetConfig([]string{"cpus"})
+	assert.NoError(t, err)
+	assert.Equal(
+		t,
+		apiClient.SetOrUnsetConfigResult{
+			Success:    true,
+			Error:      "",
+			Properties: []string{"cpus"},
+		},
+		configUnsetResult,
+	)
+
+	allConfigGetResult, err := client.GetConfig(nil)
+	assert.NoError(t, err)
+	configs := make(map[string]interface{})
+	for k, v := range config.AllConfigs() {
+		// This is required because of https://pkg.go.dev/encoding/json#Unmarshal
+		// Unmarshal stores float64 for JSON numbers in case of interface.
+		switch v := v.Value.(type) {
+		case int:
+			configs[k] = float64(v)
+		default:
+			configs[k] = v
+		}
+	}
+	assert.Equal(
+		t,
+		apiClient.GetConfigResult{
+			Success: true,
+			Error:   "",
+			Configs: configs,
+		},
+		allConfigGetResult,
+	)
+
+	// Get result of making query for multiple property
+	configGetMultiplePropertyResult, err := client.GetConfig([]string{"cpus", "memory"})
+	assert.NoError(t, err)
+	assert.Equal(
+		t,
+		apiClient.GetConfigResult{
+			Success: true,
+			Error:   "",
+			Configs: map[string]interface{}{
+				"cpus":   float64(4),
+				"memory": float64(9216),
+			},
+		},
+		configGetMultiplePropertyResult,
+	)
+
+	// Get result of special query for multiple properties
+	configGetSpecialPropertyResult, err := client.GetConfig([]string{"a&a", "b&&&b"})
+	assert.NoError(t, err)
+	assert.Equal(
+		t,
+		apiClient.GetConfigResult{
+			Success: true,
+			Error:   "",
+			Configs: map[string]interface{}{
+				"a&a":   "foo",
+				"b&&&b": "bar",
+			},
+		},
+		configGetSpecialPropertyResult,
+	)
 }
 
 func TestTelemetry(t *testing.T) {

pkg/crc/api/client/client.go

@@ -8,6 +8,8 @@ import (
 	"io"
 	"io/ioutil"
 	"net/http"
+	"net/url"
+	"strings"
 )
 
 type Client struct {
@@ -109,17 +111,12 @@ func (c *Client) WebconsoleURL() (ConsoleResult, error) {
 
 func (c *Client) GetConfig(configs []string) (GetConfigResult, error) {
 	var gcr = GetConfigResult{}
-	var data = new(bytes.Buffer)
-
-	if len(configs) > 0 {
-		cfg := GetOrUnsetConfigRequest{
-			Properties: configs,
-		}
-		if err := json.NewEncoder(data).Encode(cfg); err != nil {
-			return gcr, fmt.Errorf("Failed to encode data to JSON: %w", err)
-		}
+	var escapeConfigs []string
+	for _, v := range configs {
+		escapeConfigs = append(escapeConfigs, url.QueryEscape(v))
 	}
-	body, err := c.sendPostRequest("/config/get", data)
+	queryString := strings.Join(escapeConfigs, "&")
+	body, err := c.sendGetRequest(fmt.Sprintf("/config?%s", queryString))
 	if err != nil {
 		return gcr, err
 	}
@@ -142,7 +139,7 @@ func (c *Client) SetConfig(configs SetConfigRequest) (SetOrUnsetConfigResult, er
 		return scr, fmt.Errorf("Failed to encode data to JSON: %w", err)
 	}
 
-	body, err := c.sendPostRequest("/config/set", data)
+	body, err := c.sendPostRequest("/config", data)
 	if err != nil {
 		return scr, err
 	}
@@ -164,7 +161,7 @@ func (c *Client) UnsetConfig(configs []string) (SetOrUnsetConfigResult, error) {
 	if err := json.NewEncoder(data).Encode(cfg); err != nil {
 		return ucr, fmt.Errorf("Failed to encode data to JSON: %w", err)
 	}
-	body, err := c.sendPostRequest("/config/unset", data)
+	body, err := c.sendDeleteRequest("/config", data)
 	if err != nil {
 		return ucr, err
 	}
@@ -221,11 +218,9 @@ func (c *Client) sendGetRequest(url string) ([]byte, error) {
 		return nil, err
 	}
 	defer res.Body.Close()
-
 	if res.StatusCode != http.StatusOK {
 		return nil, fmt.Errorf("Error occurred sending GET request to : %s : %d", url, res.StatusCode)
 	}
-
 	body, err := ioutil.ReadAll(res.Body)
 	if err != nil {
 		return nil, fmt.Errorf("Unknown error reading response: %w", err)
@@ -234,7 +229,15 @@ func (c *Client) sendGetRequest(url string) ([]byte, error) {
 }
 
 func (c *Client) sendPostRequest(url string, data io.Reader) ([]byte, error) {
-	req, err := http.NewRequest("POST", fmt.Sprintf("%s%s", c.base, url), data)
+	return c.sendRequest(url, http.MethodPost, data)
+}
+
+func (c *Client) sendDeleteRequest(url string, data io.Reader) ([]byte, error) {
+	return c.sendRequest(url, http.MethodDelete, data)
+}
+
+func (c *Client) sendRequest(url string, method string, data io.Reader) ([]byte, error) {
+	req, err := http.NewRequest(method, fmt.Sprintf("%s%s", c.base, url), data)
 	if err != nil {
 		return nil, err
 	}
@@ -246,8 +249,15 @@ func (c *Client) sendPostRequest(url string, data io.Reader) ([]byte, error) {
 	}
 	defer res.Body.Close()
 
-	if res.StatusCode != http.StatusOK && res.StatusCode != http.StatusCreated {
-		return nil, fmt.Errorf("Error occurred sending POST request to : %s : %d", url, res.StatusCode)
+	switch method {
+	case http.MethodPost:
+		if res.StatusCode != http.StatusOK && res.StatusCode != http.StatusCreated {
+			return nil, fmt.Errorf("Error occurred sending POST request to : %s : %d", url, res.StatusCode)
+		}
+	case http.MethodDelete, http.MethodGet:
+		if res.StatusCode != http.StatusOK {
+			return nil, fmt.Errorf("Error occurred sending %s request to : %s : %d", method, url, res.StatusCode)
+		}
 	}
 
 	body, err := ioutil.ReadAll(res.Body)

pkg/crc/api/handlers.go

@@ -214,9 +214,10 @@ func (h *Handler) UnsetConfig(c *context) error {
 }
 
 func (h *Handler) GetConfig(c *context) error {
+	queries := c.url.Query()
 	var req client.GetOrUnsetConfigRequest
-	if err := c.Bind(&req); err != nil {
-		return err
+	for key := range queries {
+		req.Properties = append(req.Properties, key)
 	}
 
 	if len(req.Properties) == 0 {

pkg/crc/api/helpers_test.go

@@ -12,6 +12,8 @@ func setupNewInMemoryConfig() config.Storage {
 	cfg := config.New(&skipPreflights{
 		storage: storage,
 	})
+	cfg.AddSetting("a&a", "foo", nil, nil, "test special string")
+	cfg.AddSetting("b&&&b", "bar", nil, nil, "test special string")
 	config.RegisterSettings(cfg)
 	preflight.RegisterSettings(cfg)