fix&refactor

authorizer/src/asapo_authorizer/server/folder_token.go

@@ -3,6 +3,7 @@ package server
 import (
 	"asapo_common/structs"
 	"asapo_common/utils"
+	"asapo_common/version"
 	"net/http"
 	"time"
 	log "asapo_common/logger"
@@ -11,20 +12,20 @@ import (
 )
 
 type folderTokenRequest struct {
-	Folder string
+	Folder     string
 	BeamtimeId string
 	Token      string
 }
 
 type folderToken struct {
-	Token      string
+	Token string
 }
 
 /*func routeFolderToken(w http.ResponseWriter, r *http.Request) {
 	utils.ProcessJWTAuth(processFolderTokenRequest,settings.secret)(w,r)
 }*/
 
-func prepareJWTToken(request folderTokenRequest) (string,error) {
+func prepareJWTToken(request folderTokenRequest) (string, error) {
 	var claims utils.CustomClaims
 	var extraClaim structs.FolderTokenTokenExtraClaim
 
@@ -35,40 +36,39 @@ func prepareJWTToken(request folderTokenRequest) (string,error) {
 
 }
 
-func folderTokenResponce(token string) []byte{
+func folderTokenResponce(token string) []byte {
 	return []byte(token)
 }
 
 func checkBeamtimeToken(request folderTokenRequest) error {
-	_,err :=  checkToken(request.Token,utils.SubjectFromBeamtime(request.BeamtimeId))
+	_, err := checkToken(request.Token, utils.SubjectFromBeamtime(request.BeamtimeId))
 	return err
 }
 
-
-func extractFolderTokenrequest(r *http.Request) (folderTokenRequest,error) {
+func extractFolderTokenrequest(r *http.Request) (folderTokenRequest, error) {
 	var request folderTokenRequest
-	err := utils.ExtractRequest(r,&request)
+	err := utils.ExtractRequest(r, &request)
 	if err != nil {
-		return folderTokenRequest{},err
+		return folderTokenRequest{}, err
 	}
 
-	if len(request.Folder)==0 ||len(request.BeamtimeId)==0 || len(request.Token) == 0 {
-		return folderTokenRequest{},errors.New("some request fields are empty")
+	if len(request.Folder) == 0 || len(request.BeamtimeId) == 0 || len(request.Token) == 0 {
+		return folderTokenRequest{}, errors.New("some request fields are empty")
 	}
-	return request,nil
+	return request, nil
 
 }
 
 func checkBeamtimeFolder(request folderTokenRequest) error {
-	beamtimeMeta, err := findMeta(SourceCredentials{request.BeamtimeId,"auto","","",""})
+	beamtimeMeta, err := findMeta(SourceCredentials{request.BeamtimeId, "auto", "", "", ""})
 	if err != nil {
-		log.Error("cannot get beamtime meta"+err.Error())
+		log.Error("cannot get beamtime meta" + err.Error())
 		return err
 	}
 
 	folder := filepath.Clean(request.Folder)
-	if (folder != filepath.Clean(beamtimeMeta.OnlinePath) && folder != filepath.Clean(beamtimeMeta.OfflinePath)) {
-		err_string := folder + " does not match beamtime folders "+beamtimeMeta.OnlinePath+" or " +beamtimeMeta.OfflinePath
+	if folder != filepath.Clean(beamtimeMeta.OnlinePath) && folder != filepath.Clean(beamtimeMeta.OfflinePath) {
+		err_string := folder + " does not match beamtime folders " + beamtimeMeta.OnlinePath + " or " + beamtimeMeta.OfflinePath
 		log.Error(err_string)
 		return errors.New(err_string)
 	}
@@ -76,28 +76,37 @@ func checkBeamtimeFolder(request folderTokenRequest) error {
 	return nil
 }
 
+func checkAuthorizerApiVersion(w http.ResponseWriter, r *http.Request) bool {
+	_, ok := utils.PrecheckApiVersion(w, r, version.GetConsumerProtocolVersion())
+	return ok
+}
+
 func routeFolderToken(w http.ResponseWriter, r *http.Request) {
+	if ok := checkAuthorizerApiVersion(w, r); !ok {
+		return
+	}
+
 	request, err := extractFolderTokenrequest(r)
 	if err != nil {
-		utils.WriteServerError(w,err,http.StatusBadRequest)
+		utils.WriteServerError(w, err, http.StatusBadRequest)
 		return
 	}
 
 	err = checkBeamtimeToken(request)
 	if err != nil {
-		utils.WriteServerError(w,err,http.StatusUnauthorized)
+		utils.WriteServerError(w, err, http.StatusUnauthorized)
 		return
 	}
 
 	err = checkBeamtimeFolder(request)
 	if err != nil {
-		utils.WriteServerError(w,err,http.StatusUnauthorized)
+		utils.WriteServerError(w, err, http.StatusUnauthorized)
 		return
 	}
 
 	token, err := prepareJWTToken(request)
 	if err != nil {
-		utils.WriteServerError(w,err,http.StatusInternalServerError)
+		utils.WriteServerError(w, err, http.StatusInternalServerError)
 		return
 	}
 

authorizer/src/asapo_authorizer/server/folder_token_test.go

@@ -50,7 +50,7 @@ func TestFolderToken(t *testing.T) {
 		if test.status == http.StatusBadRequest {
 			request =makeRequest(authorizationRequest{})
 		}
-		w := doPostRequest("/folder",request,"")
+		w := doPostRequest("/v0.1/folder",request,"")
 		if w.Code == http.StatusOK {
 			body, _ := ioutil.ReadAll(w.Body)
 			claims,_ := utils.CheckJWTToken(string(body),"secret_folder")
@@ -66,3 +66,11 @@ func TestFolderToken(t *testing.T) {
 	}
 }
 
+func TestFolderTokenWrongProtocol(t *testing.T) {
+		request :=  makeRequest(folderTokenRequest{"abs_path","beamtime_id","token"})
+		w := doPostRequest("/v0.2/folder",request,"")
+		assert.Equal(t, http.StatusUnsupportedMediaType, w.Code, "wrong protocol")
+}
+
+
+

authorizer/src/asapo_authorizer/server/listroutes.go

@@ -26,7 +26,7 @@ var listRoutes = utils.Routes{
 	utils.Route{
 		"Folder Token",
 		"POST",
-		"/folder",
+		"/{apiver}/folder",
 		routeFolderToken,
 	},
 	utils.Route{

broker/src/asapo_broker/server/get_commands_test.go

@@ -58,7 +58,7 @@ func (suite *GetCommandsTestSuite) TestGetCommandsCallsCorrectRoutine() {
 	for _, test := range testsGetCommand {
 		suite.mock_db.On("ProcessRequest", database.Request{DbName: expectedDBName, DbCollectionName: test.stream, GroupId: test.groupid, Op: test.command, ExtraParam: test.externalParam}).Return([]byte("Hello"), nil)
 		logger.MockLog.On("Debug", mock.MatchedBy(containsMatcher("processing request "+test.command)))
-		w := doRequest("/database/" + expectedBeamtimeId + "/" + expectedSource + "/" + test.reqString+correctTokenSuffix+test.queryParams)
+		w := doRequest("/beamtime/" + expectedBeamtimeId + "/" + expectedSource + "/" + test.reqString+correctTokenSuffix+test.queryParams)
 		suite.Equal(http.StatusOK, w.Code, test.command+ " OK")
 		suite.Equal("Hello", string(w.Body.Bytes()), test.command+" sends data")
 	}

broker/src/asapo_broker/server/get_health.go

@@ -9,6 +9,5 @@ func routeGetHealth(w http.ResponseWriter, r *http.Request) {
 	if err != nil {
 		ReconnectDb()
 	}
-	r.Header.Set("Content-type", "application/json")
 	w.WriteHeader(http.StatusNoContent)
 }

broker/src/asapo_broker/server/get_health_test.go

@@ -34,7 +34,7 @@ func TestGetHealthTestSuite(t *testing.T) {
 
 func (suite *GetHealthTestSuite) TestGetHealthOk() {
 	suite.mock_db.On("Ping").Return(nil)
-	w := doRequest("/health")
+	w := doRequest("/health","GET","","")
 	suite.Equal(http.StatusNoContent, w.Code)
 }
 
@@ -44,6 +44,6 @@ func (suite *GetHealthTestSuite) TestGetHealthTriesToReconnectsToDataBase() {
 
 	ExpectReconnect(suite.mock_db)
 
-	w := doRequest("/health")
+	w := doRequest("/health","GET","","")
 	suite.Equal(http.StatusNoContent, w.Code)
 }

broker/src/asapo_broker/server/get_meta_test.go

@@ -35,7 +35,7 @@ func TestGetMetaTestSuite(t *testing.T) {
 func (suite *GetMetaTestSuite) TestGetMetaOK() {
 	suite.mock_db.On("ProcessRequest", database.Request{DbName: expectedDBName, DbCollectionName: expectedStream, Op: "meta", ExtraParam: "1"}).Return([]byte(""), nil)
 	logger.MockLog.On("Debug", mock.MatchedBy(containsMatcher("processing request meta")))
-	w := doRequest("/database/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/0/meta"  + "/1" + correctTokenSuffix,"GET")
+	w := doRequest("/beamtime/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/0/meta"  + "/1" + correctTokenSuffix,"GET")
 	suite.Equal(http.StatusOK, w.Code, "meta OK")
 }
 

broker/src/asapo_broker/server/listroutes.go

@@ -8,73 +8,73 @@ var listRoutes = utils.Routes{
 	utils.Route{
 		"GetNext",
 		"Get",
-		"/database/{dbname}/{datasource}/{stream}/{groupid}/next",
+		"/{apiver}/beamtime/{beamtime}/{datasource}/{stream}/{groupid}/next",
 		routeGetNext,
 	},
 	utils.Route{
 		"GetSize",
 		"Get",
-		"/database/{dbname}/{datasource}/{stream}/size",
+		"/{apiver}/beamtime/{beamtime}/{datasource}/{stream}/size",
 		routeGetSize,
 	},
 	utils.Route{
 		"GetStreams",
 		"Get",
-		"/database/{dbname}/{datasource}/{stream}/streams",
+		"/{apiver}/beamtime/{beamtime}/{datasource}/{stream}/streams",
 		routeGetStreams,
 	},
 	utils.Route{
 		"GetLast",
 		"Get",
-		"/database/{dbname}/{datasource}/{stream}/0/last",
+		"/{apiver}/beamtime/{beamtime}/{datasource}/{stream}/0/last",
 		routeGetLast,
 	},
 	utils.Route{
 		"GetLastAck",
 		"Get",
-		"/database/{dbname}/{datasource}/{stream}/{groupid}/lastack",
+		"/{apiver}/beamtime/{beamtime}/{datasource}/{stream}/{groupid}/lastack",
 		routeGetLastAck,
 	},
 	utils.Route{
 		"GetNacks",
 		"Get",
-		"/database/{dbname}/{datasource}/{stream}/{groupid}/nacks",
+		"/{apiver}/beamtime/{beamtime}/{datasource}/{stream}/{groupid}/nacks",
 		routeGetNacks,
 	},
 	utils.Route{
 		"GetID",
 		"Get",
-		"/database/{dbname}/{datasource}/{stream}/0/{id}",
+		"/{apiver}/beamtime/{beamtime}/{datasource}/{stream}/0/{id}",
 		routeGetByID,
 	},
 	utils.Route{
 		"GetMeta",
 		"Get",
-		"/database/{dbname}/{datasource}/{stream}/0/meta/{id}",
+		"/{apiver}/beamtime/{beamtime}/{datasource}/{stream}/0/meta/{id}",
 		routeGetMeta,
 	},
 	utils.Route{
 		"CreateGroup",
 		"Post",
-		"/creategroup",
+		"/{apiver}/creategroup",
 		routeCreateGroupID,
 	},
 	utils.Route{
 		"QueryMessages",
 		"Post",
-		"/database/{dbname}/{datasource}/{stream}/0/querymessages",
+		"/{apiver}/beamtime/{beamtime}/{datasource}/{stream}/0/querymessages",
 		routeQueryMessages,
 	},
 	utils.Route{
 		"ResetConter",
 		"Post",
-		"/database/{dbname}/{datasource}/{stream}/{groupid}/resetcounter",
+		"/{apiver}/beamtime/{beamtime}/{datasource}/{stream}/{groupid}/resetcounter",
 		routeResetCounter,
 	},
 	utils.Route{
 		"MessageOp",
 		"Post",
-		"/database/{dbname}/{datasource}/{stream}/{groupid}/{id}",
+		"/{apiver}/beamtime/{beamtime}/{datasource}/{stream}/{groupid}/{id}",
 		routeMessageOp,
 	},
 	utils.Route{

broker/src/asapo_broker/server/post_create_group.go

@@ -7,6 +7,11 @@ import (
 )
 
 func routeCreateGroupID(w http.ResponseWriter, r *http.Request) {
+	if ok := checkAuthorizerApiVersion(w, r); !ok {
+		return
+	}
+
+
 	guid := xid.New()
 	w.Write([]byte(guid.String()))
 	logger.Debug("generated new group: " + guid.String())

broker/src/asapo_broker/server/post_create_group_test.go

@@ -32,3 +32,8 @@ func TestGetNewGroup(t *testing.T) {
 
 	logger.UnsetMockLog()
 }
+
+func TestGetNewGroupWrongProtocol(t *testing.T) {
+	w := doRequest("/creategroup", "POST","","/v0.2")
+	assert.Equal(t, http.StatusUnsupportedMediaType, w.Code, "wrong request")
+}

broker/src/asapo_broker/server/post_op_image_test.go

@@ -36,19 +36,19 @@ func (suite *MessageOpTestSuite) TestAckMessageOpOK() {
 	query_str := "{\"Id\":1,\"Op\":\"ackmessage\"}"
 	suite.mock_db.On("ProcessRequest", database.Request{DbName: expectedDBName, DbCollectionName: expectedStream, GroupId: expectedGroupID, Op: "ackmessage", ExtraParam: query_str}).Return([]byte(""), nil)
 	logger.MockLog.On("Debug", mock.MatchedBy(containsMatcher("processing request ackmessage")))
-	w := doRequest("/database/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/" + expectedGroupID + "/1" + correctTokenSuffix,"POST",query_str)
+	w := doRequest("/beamtime/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/" + expectedGroupID + "/1" + correctTokenSuffix,"POST",query_str)
 	suite.Equal(http.StatusOK, w.Code, "ackmessage OK")
 }
 
 
 func (suite *MessageOpTestSuite) TestAckMessageOpErrorWrongOp() {
 	query_str := "\"Id\":1,\"Op\":\"ackmessage\"}"
-	w := doRequest("/database/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/" + expectedGroupID + "/1" + correctTokenSuffix,"POST",query_str)
+	w := doRequest("/beamtime/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/" + expectedGroupID + "/1" + correctTokenSuffix,"POST",query_str)
 	suite.Equal(http.StatusBadRequest, w.Code, "ackmessage wrong")
 }
 
 func (suite *MessageOpTestSuite) TestAckMessageOpErrorWrongID() {
 	query_str := "{\"Id\":1,\"Op\":\"ackmessage\"}"
-	w := doRequest("/database/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/" + expectedGroupID + "/bla" + correctTokenSuffix,"POST",query_str)
+	w := doRequest("/beamtime/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/" + expectedGroupID + "/bla" + correctTokenSuffix,"POST",query_str)
 	suite.Equal(http.StatusBadRequest, w.Code, "ackmessage wrong")
 }

broker/src/asapo_broker/server/post_query_images_test.go

@@ -38,7 +38,7 @@ func (suite *QueryTestSuite) TestQueryOK() {
 	suite.mock_db.On("ProcessRequest", database.Request{DbName: expectedDBName, DbCollectionName: expectedStream,Op: "querymessages", ExtraParam: query_str}).Return([]byte("{}"), nil)
 	logger.MockLog.On("Debug", mock.MatchedBy(containsMatcher("processing request querymessages")))
 
-	w := doRequest("/database/"+expectedBeamtimeId+"/"+expectedSource+"/"+expectedStream+"/0/querymessages"+correctTokenSuffix, "POST", query_str)
+	w := doRequest("/beamtime/"+expectedBeamtimeId+"/"+expectedSource+"/"+expectedStream+"/0/querymessages"+correctTokenSuffix, "POST", query_str)
 	suite.Equal(http.StatusOK, w.Code, "Query OK")
 }
 

broker/src/asapo_broker/server/post_reset_counter_test.go

@@ -38,6 +38,6 @@ func (suite *ResetCounterTestSuite) TestResetCounterOK() {
 
 	logger.MockLog.On("Debug", mock.MatchedBy(containsMatcher("processing request resetcounter")))
 
-	w := doRequest("/database/"+expectedBeamtimeId+"/"+expectedSource+"/"+expectedStream+"/"+expectedGroupID+"/resetcounter"+correctTokenSuffix+"&value=10", "POST")
+	w := doRequest("/beamtime/"+expectedBeamtimeId+"/"+expectedSource+"/"+expectedStream+"/"+expectedGroupID+"/resetcounter"+correctTokenSuffix+"&value=10", "POST")
 	suite.Equal(http.StatusOK, w.Code, "ResetCounter OK")
 }

broker/src/asapo_broker/server/process_request.go

@@ -5,13 +5,14 @@ import (
 	"asapo_common/logger"
 	log "asapo_common/logger"
 	"asapo_common/utils"
+	"asapo_common/version"
 	"github.com/gorilla/mux"
 	"net/http"
 )
 
 func extractRequestParameters(r *http.Request, needGroupID bool) (string, string, string, string, bool) {
 	vars := mux.Vars(r)
-	db_name, ok1 := vars["dbname"]
+	db_name, ok1 := vars["beamtime"]
 
 	datasource, ok3 := vars["datasource"]
 	stream, ok4 := vars["stream"]
@@ -49,8 +50,17 @@ func checkGroupID(w http.ResponseWriter, needGroupID bool, group_id string, db_n
 	return false
 }
 
+func checkAuthorizerApiVersion(w http.ResponseWriter, r *http.Request) bool {
+	_, ok := utils.PrecheckApiVersion(w, r, version.GetConsumerProtocolVersion())
+	return ok
+}
+
 func processRequest(w http.ResponseWriter, r *http.Request, op string, extra_param string, needGroupID bool) {
-	r.Header.Set("Content-type", "application/json")
+	if ok := checkAuthorizerApiVersion(w, r); !ok {
+		return
+	}
+
+
 	w.Header().Set("Access-Control-Allow-Origin", "*")
 	db_name, datasource, stream, group_id, ok := extractRequestParameters(r, needGroupID)
 	if !ok {

broker/src/asapo_broker/server/process_request_test.go

@@ -78,16 +78,20 @@ func doRequest(path string, extra_params ...string) *httptest.ResponseRecorder {
 	if len(extra_params) > 1 {
 		body = strings.NewReader(extra_params[1])
 	}
+	ver := "/v0.1"
+	if len(extra_params) > 2 {
+		ver = extra_params[2]
+	}
 
 	mux := utils.NewRouter(listRoutes)
-	req, _ := http.NewRequest(m, path, body)
+	req, _ := http.NewRequest(m, ver+path, body)
 	w := httptest.NewRecorder()
 	mux.ServeHTTP(w, req)
 	return w
 }
 
 func TestProcessRequestWithoutDatabaseName(t *testing.T) {
-	w := doRequest("/database/next")
+	w := doRequest("/beamtime/next")
 	assert.Equal(t, http.StatusNotFound, w.Code, "no database name")
 }
 
@@ -124,7 +128,7 @@ func TestProcessRequestTestSuite(t *testing.T) {
 func (suite *ProcessRequestTestSuite) TestProcessRequestWithWrongToken() {
 	logger.MockLog.On("Error", mock.MatchedBy(containsMatcher("wrong JWT token")))
 
-	w := doRequest("/database/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/" + expectedGroupID + "/next" + suffixWithWrongToken)
+	w := doRequest("/beamtime/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/" + expectedGroupID + "/next" + suffixWithWrongToken)
 
 	suite.Equal(http.StatusUnauthorized, w.Code, "wrong token")
 }
@@ -132,7 +136,7 @@ func (suite *ProcessRequestTestSuite) TestProcessRequestWithWrongToken() {
 func (suite *ProcessRequestTestSuite) TestProcessRequestWithNoToken() {
 	logger.MockLog.On("Error", mock.MatchedBy(containsMatcher("cannot extract")))
 
-	w := doRequest("/database/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/" + expectedGroupID + "/next" + wrongTokenSuffix)
+	w := doRequest("/beamtime/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/" + expectedGroupID + "/next" + wrongTokenSuffix)
 
 	suite.Equal(http.StatusUnauthorized, w.Code, "no token")
 }
@@ -146,7 +150,7 @@ func (suite *ProcessRequestTestSuite) TestProcessRequestWithWrongDatabaseName()
 
 	logger.MockLog.On("Debug", mock.MatchedBy(containsMatcher("processing request next")))
 
-	w := doRequest("/database/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/" + expectedGroupID + "/next" + correctTokenSuffix)
+	w := doRequest("/beamtime/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/" + expectedGroupID + "/next" + correctTokenSuffix)
 
 	suite.Equal(http.StatusConflict, w.Code, "wrong database name")
 }
@@ -162,7 +166,7 @@ func (suite *ProcessRequestTestSuite) TestProcessRequestWithConnectionError() {
 	ExpectReconnect(suite.mock_db)
 	logger.MockLog.On("Debug", mock.MatchedBy(containsMatcher("reconnected")))
 
-	w := doRequest("/database/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/" + expectedGroupID + "/next" + correctTokenSuffix)
+	w := doRequest("/beamtime/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/" + expectedGroupID + "/next" + correctTokenSuffix)
 	time.Sleep(time.Second)
 	suite.Equal(http.StatusNotFound, w.Code, "data not found")
 }
@@ -177,7 +181,7 @@ func (suite *ProcessRequestTestSuite) TestProcessRequestWithInternalDBError() {
 	logger.MockLog.On("Debug", mock.MatchedBy(containsMatcher("reconnected")))
 
 	ExpectReconnect(suite.mock_db)
-	w := doRequest("/database/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/" + expectedGroupID + "/next" + correctTokenSuffix)
+	w := doRequest("/beamtime/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/" + expectedGroupID + "/next" + correctTokenSuffix)
 	time.Sleep(time.Second)
 
 	suite.Equal(http.StatusNotFound, w.Code, "internal error")
@@ -191,13 +195,13 @@ func (suite *ProcessRequestTestSuite) TestProcessRequestAddsCounter() {
 
 	logger.MockLog.On("Debug", mock.MatchedBy(containsMatcher("processing request next in "+expectedDBName)))
 
-	doRequest("/database/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/" + expectedGroupID + "/next" + correctTokenSuffix)
+	doRequest("/beamtime/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/" + expectedGroupID + "/next" + correctTokenSuffix)
 	suite.Equal(1, statistics.GetCounter(), "ProcessRequest increases counter")
 }
 
 func (suite *ProcessRequestTestSuite) TestProcessRequestWrongGroupID() {
 	logger.MockLog.On("Error", mock.MatchedBy(containsMatcher("wrong groupid")))
-	w := doRequest("/database/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/" + wrongGroupID + "/next" + correctTokenSuffix)
+	w := doRequest("/beamtime/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/" + wrongGroupID + "/next" + correctTokenSuffix)
 	suite.Equal(http.StatusBadRequest, w.Code, "wrong group id")
 }
 
@@ -208,5 +212,11 @@ func (suite *ProcessRequestTestSuite) TestProcessRequestAddsDataset() {
 
 	logger.MockLog.On("Debug", mock.MatchedBy(containsMatcher("processing request next in "+expectedDBName)))
 
-	doRequest("/database/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/" + expectedGroupID + "/next" + correctTokenSuffix + "&dataset=true")
+	doRequest("/beamtime/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/" + expectedGroupID + "/next" + correctTokenSuffix + "&dataset=true")
+}
+
+
+func (suite *ProcessRequestTestSuite) TestProcessRequestErrorOnWrongProtocol() {
+	w := doRequest("/beamtime/" + expectedBeamtimeId + "/" + expectedSource + "/" + expectedStream + "/" + expectedGroupID + "/next" + correctTokenSuffix,"GET","","/v0.2")
+	suite.Equal(http.StatusUnsupportedMediaType, w.Code, "wrong protocol")
 }

common/cpp/include/asapo/common/version.h.in

@@ -2,7 +2,7 @@
 #define ASAPO_VERSION_H
 
 #include <iostream>
-#include <string>
+#include "string.h"
 
 #include "data_structs.h"
 

common/go/src/asapo_common/utils/http.go

@@ -10,7 +10,8 @@ func ExtractRequest(r *http.Request, request interface{}) error {
 	return decoder.Decode(request)
 }
 
-func WriteServerError(w http.ResponseWriter, err error,code int) {
+func WriteServerError(w http.ResponseWriter, err error, code int) {
 	w.WriteHeader(code)
 	w.Write([]byte(err.Error()))
-}
\ No newline at end of file
+}
+

common/go/src/asapo_common/utils/version.go

+package utils
+
+import (
+	"errors"
+	"github.com/gorilla/mux"
+	"net/http"
+	"strconv"
+	"strings"
+)
+
+
+func VersionToNumber(ver string) int {
+	ver = strings.TrimPrefix(ver,"v")
+	floatNum, err := strconv.ParseFloat(ver, 64)
+	if err!=nil {
+		return 0
+	}
+	return int(floatNum*1000)
+}
+
+
+func ExtractVersion(r *http.Request) (int, error) {
+	vars := mux.Vars(r)
+	ver_str, ok := vars["apiver"]
+	if !ok {
+		return 0, errors.New("cannot extract version")
+	}
+	ver := VersionToNumber(ver_str)
+	if ver == 0 {
+		return 0, errors.New("cannot extract version")
+	}
+	return ver, nil
+}
+
+func PrecheckApiVersion(w http.ResponseWriter, r *http.Request, currentVersion string) (apiVer int, ok bool) {
+	apiVer, err := ExtractVersion(r)
+	if err != nil {
+		WriteServerError(w, err, http.StatusBadRequest)
+		return 0, false
+	}
+	if apiVer > VersionToNumber(currentVersion) {
+		WriteServerError(w, errors.New("version not supported"), http.StatusUnsupportedMediaType)
+		return 0, false
+	}
+	return apiVer, true
+}

common/go/src/asapo_common/version/version.go

@@ -7,6 +7,17 @@ import (
 )
 
 var version string
+var consumerProtocolVersion string
+var producerProtocolVersion string
+
+func GetProducerProtocolVersion() string {
+	return producerProtocolVersion
+}
+
+func GetConsumerProtocolVersion() string {
+	return consumerProtocolVersion
+}
+
 
 func GetVersion() string {
     return version

common/go/src/asapo_common/version/version_lib.go.in

@@ -4,4 +4,6 @@ package version
 // This file is overridden on build with build-time informations.
 func init(){
 	version   = "@ASAPO_VERSION@@ASAPO_VERSION_COMMIT@"
+	consumerProtocolVersion = "@ASAPO_CONSUMER_PROTOCOL@"
+    producerProtocolVersion = "@ASAPO_PRODUCER_PROTOCOL@"
 }