Pass OCM test suite

internal/grpc/services/ocmcore/ocmcore.go

@@ -22,7 +22,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"strings"
 
 	ocmcore "github.com/cs3org/go-cs3apis/cs3/ocm/core/v1beta1"
 	ocm "github.com/cs3org/go-cs3apis/cs3/sharing/ocm/v1beta1"
@@ -107,18 +106,11 @@ func (s *service) UnprotectedEndpoints() []string {
 	return []string{"/cs3.ocm.core.v1beta1.OcmCoreAPI/CreateOCMCoreShare"}
 }
 
+// CreateOCMCoreShare is called when an OCM request comes into this reva instance from
 func (s *service) CreateOCMCoreShare(ctx context.Context, req *ocmcore.CreateOCMCoreShareRequest) (*ocmcore.CreateOCMCoreShareResponse, error) {
-	parts := strings.Split(req.ProviderId, ":")
-	if len(parts) < 2 {
-		err := errtypes.BadRequest("resource ID does not follow the layout storageid:opaqueid " + req.ProviderId)
-		return &ocmcore.CreateOCMCoreShareResponse{
-			Status: status.NewInternal(ctx, err, "error decoding resource ID"),
-		}, nil
-	}
-
 	resource := &provider.ResourceId{
-		StorageId: parts[0],
-		OpaqueId:  parts[1],
+		StorageId: "remote",
+		OpaqueId:  req.ProviderId,
 	}
 
 	var resourcePermissions *provider.ResourcePermissions

internal/http/services/ocmd/config.go

@@ -30,7 +30,7 @@ type configData struct {
 	Enabled       bool            `json:"enabled" xml:"enabled"`
 	APIVersion    string          `json:"apiVersion" xml:"apiVersion"`
 	Host          string          `json:"host" xml:"host"`
-	Endpoint      string          `json:"endpoint" xml:"endpoint"`
+	Endpoint      string          `json:"endPoint" xml:"endPoint"`
 	Provider      string          `json:"provider" xml:"provider"`
 	ResourceTypes []resourceTypes `json:"resourceTypes" xml:"resourceTypes"`
 }
@@ -61,7 +61,11 @@ func (h *configHandler) init(c *Config) {
 		h.c.Provider = "cernbox"
 	}
 	h.c.Enabled = true
-	h.c.Endpoint = fmt.Sprintf("https://%s/%s", h.c.Host, c.Prefix)
+	if len(c.Prefix) > 0 {
+		h.c.Endpoint = fmt.Sprintf("https://%s/%s", h.c.Host, c.Prefix)
+	} else {
+		h.c.Endpoint = fmt.Sprintf("https://%s", h.c.Host)
+	}
 	h.c.ResourceTypes = []resourceTypes{{
 		Name:       "file",
 		ShareTypes: []string{"user"},

internal/http/services/ocmd/ocmd.go

@@ -47,9 +47,9 @@ type Config struct {
 func (c *Config) init() {
 	c.GatewaySvc = sharedconf.GetGatewaySVC(c.GatewaySvc)
 
-	if c.Prefix == "" {
-		c.Prefix = "ocm"
-	}
+	// if c.Prefix == "" {
+	// 	c.Prefix = "ocm"
+	// }
 }
 
 type svc struct {
@@ -78,6 +78,8 @@ func New(m map[string]interface{}, log *zerolog.Logger) (global.Service, error)
 	s.InvitesHandler = new(invitesHandler)
 	s.SharesHandler.init(s.Conf)
 	s.NotificationsHandler.init(s.Conf)
+	log.Debug().Str("initializing ConfigHandler Host", s.Conf.Host)
+
 	s.ConfigHandler.init(s.Conf)
 	s.InvitesHandler.init(s.Conf)
 
@@ -94,7 +96,7 @@ func (s *svc) Prefix() string {
 }
 
 func (s *svc) Unprotected() []string {
-	return []string{"/invites/accept", "/shares", "/ocm-provider"}
+	return []string{"/invites/accept", "/shares", "/ocm-provider", "/notifications"}
 }
 
 func (s *svc) Handler() http.Handler {

internal/http/services/ocmd/shares.go

@@ -22,6 +22,8 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"io"
+	"mime"
 	"net/http"
 	"time"
 
@@ -59,9 +61,23 @@ func (h *sharesHandler) Handler() http.Handler {
 func (h *sharesHandler) createShare(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 	log := appctx.GetLogger(ctx)
-
-	shareWith, protocol, meshProvider := r.FormValue("shareWith"), r.FormValue("protocol"), r.FormValue("meshProvider")
-	resource, providerID, owner := r.FormValue("name"), r.FormValue("providerId"), r.FormValue("owner")
+	contentType, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
+	var shareWith, protocol, meshProvider, resource, providerID, owner string
+	if err == nil && contentType == "application/json" {
+		defer r.Body.Close()
+		reqBody, err := io.ReadAll(r.Body)
+		if err == nil {
+			reqMap := make(map[string]string)
+			err = json.Unmarshal(reqBody, &reqMap)
+			if err == nil {
+				shareWith, protocol, meshProvider = reqMap["shareWith"], reqMap["protocol"], reqMap["meshProvider"]
+				resource, providerID, owner = reqMap["name"], reqMap["providerId"], reqMap["owner"]
+			}
+		}
+	} else {
+		shareWith, protocol, meshProvider = r.FormValue("shareWith"), r.FormValue("protocol"), r.FormValue("meshProvider")
+		resource, providerID, owner = r.FormValue("name"), r.FormValue("providerId"), r.FormValue("owner")
+	}
 
 	if resource == "" || providerID == "" || owner == "" {
 		WriteError(w, r, APIErrorInvalidParameter, "missing details about resource to be shared", nil)

pkg/ocm/share/manager/json/json.go

@@ -305,15 +305,19 @@ func (m *mgr) Share(ctx context.Context, md *provider.ResourceId, g *ocm.ShareGr
 			}
 		}
 
-		requestBody := url.Values{
-			"shareWith":    {g.Grantee.GetUserId().OpaqueId},
-			"name":         {name},
-			"providerId":   {fmt.Sprintf("%s:%s", md.StorageId, md.OpaqueId)},
-			"owner":        {userID.OpaqueId},
-			"protocol":     {string(protocol)},
-			"meshProvider": {userID.Idp},
+		requestBodyMap := map[string]string{
+			"shareWith":    g.Grantee.GetUserId().OpaqueId,
+			"name":         name,
+			"providerId":   fmt.Sprintf("%s:%s", md.StorageId, md.OpaqueId),
+			"owner":        userID.OpaqueId,
+			"protocol":     string(protocol),
+			"meshProvider": userID.Idp,
+		}
+		requestBody, err := json.Marshal(requestBodyMap)
+		if err != nil {
+			err = errors.Wrap(err, "error marshalling request body")
+			return nil, err
 		}
-
 		ocmEndpoint, err := getOCMEndpoint(pi)
 		if err != nil {
 			return nil, err
@@ -325,11 +329,11 @@ func (m *mgr) Share(ctx context.Context, md *provider.ResourceId, g *ocm.ShareGr
 		u.Path = path.Join(u.Path, createOCMCoreShareEndpoint)
 		recipientURL := u.String()
 
-		req, err := http.NewRequest("POST", recipientURL, strings.NewReader(requestBody.Encode()))
+		req, err := http.NewRequest("POST", recipientURL, strings.NewReader(string(requestBody)))
 		if err != nil {
 			return nil, errors.Wrap(err, "json: error framing post request")
 		}
-		req.Header.Set("Content-Type", "application/x-www-form-urlencoded; param=value")
+		req.Header.Set("Content-Type", "application/json; param=value")
 
 		resp, err := m.client.Do(req)
 		if err != nil {
@@ -338,7 +342,7 @@ func (m *mgr) Share(ctx context.Context, md *provider.ResourceId, g *ocm.ShareGr
 		}
 
 		defer resp.Body.Close()
-		if resp.StatusCode != http.StatusOK {
+		if (resp.StatusCode != http.StatusCreated) && (resp.StatusCode != http.StatusOK) {
 			respBody, e := ioutil.ReadAll(resp.Body)
 			if e != nil {
 				e = errors.Wrap(e, "json: error reading request body")

pkg/rhttp/rhttp.go

@@ -78,6 +78,8 @@ type config struct {
 	Address     string                            `mapstructure:"address"`
 	Services    map[string]map[string]interface{} `mapstructure:"services"`
 	Middlewares map[string]map[string]interface{} `mapstructure:"middlewares"`
+	CertFile    string                            `mapstructure:"certfile"`
+	KeyFile     string                            `mapstructure:"keyfile"`
 }
 
 func (c *config) init() {
@@ -109,8 +111,13 @@ func (s *Server) Start(ln net.Listener) error {
 	s.httpServer.Handler = handler
 	s.listener = ln
 
-	s.log.Info().Msgf("http server listening at %s://%s", "http", s.conf.Address)
-	err = s.httpServer.Serve(s.listener)
+	if (s.conf.CertFile != "") && (s.conf.KeyFile != "") {
+		s.log.Info().Msgf("https server listening at https://%s '%s' '%s'", s.conf.Address, s.conf.CertFile, s.conf.KeyFile)
+		err = s.httpServer.ServeTLS(s.listener, s.conf.CertFile, s.conf.KeyFile)
+	} else {
+		s.log.Info().Msgf("http server listening at http://%s '%s' '%s'", s.conf.Address, s.conf.CertFile, s.conf.KeyFile)
+		err = s.httpServer.Serve(s.listener)
+	}
 	if err == nil || err == http.ErrServerClosed {
 		return nil
 	}