.github/workflows/runtests.yml

@@ -1,78 +0,0 @@
-# This is a basic workflow to help you get started with Actions
-
-name: CI
-
-# Controls when the workflow will run
-on:
-  # Triggers the workflow on push or pull request events but only for the "main" branch
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-
-  # Allows you to run this workflow manually from the Actions tab
-  workflow_dispatch:
-
-# A workflow run is made up of one or more jobs that can run sequentially or in parallel
-jobs:
-  # This workflow contains a single job called "build"
-  build:
-    # The type of runner that the job will run on
-    runs-on: ubuntu-latest
-
-    # Steps represent a sequence of tasks that will be executed as part of the job
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Set up Go
-        uses: actions/setup-go@v3
-        with:
-          go-version: 1.19
-          check-latest: true
-
-      - name: Create dir for binaries
-        run: mkdir builds
-
-      - name: Download DSP binary
-        run: curl -o builds/dsp https://dummy-dsp.s3.eu-central-1.amazonaws.com/dsp
-
-      - name: Making it executable
-        run: chmod +x builds/dsp
-
-      - name: Download tests binary
-        run: curl -o builds/tests https://dummy-dsp.s3.eu-central-1.amazonaws.com/tests
-
-      - name: Making it executable
-        run: chmod +x builds/tests
-
-      # your code must be built into builds/ssp binary
-      - name: Build SSP binary
-        run: go build -o builds/ssp cmd/main.go
-
-      - name: Making it executable
-        run: chmod +x builds/ssp
-
-      # run a battery of tests
-      - name: happy path
-        run: (cd builds && ./tests -test.v -test.run Test_HappyPath) && sleep 1
-
-      - name: not totally happy path, easy difficulty
-        run: (cd builds && ./tests -test.v -test.run Test_LessHappyEasy) && sleep 1
-
-      - name: not totally happy path, medium difficulty
-        run: (cd builds && ./tests -test.v -test.run Test_LessHappyMedium) && sleep 1
-
-      - name: not totally happy path, hard difficulty
-        run: (cd builds && ./tests -test.v -test.run Test_LessHappyHard) && sleep 1
-
-      - name: not happy at all, easy difficulty
-        run: (cd builds && ./tests -test.v -test.run Test_NotHappyEasy) && sleep 1
-
-      - name: not happy at all, medium difficulty
-        run: (cd builds && ./tests -test.v -test.run Test_NotHappyMedium) && sleep 1
-
-      - name: not happy at all, hard difficulty
-        run: (cd builds && ./tests -test.v -test.run Test_NotHappyHard) && sleep 1
-
-      - name: not happy at all, hardcore difficulty
-        run: (cd builds && ./tests -test.v -test.run Test_NotHappyHardcore) && sleep 1

Makefile

@@ -1,6 +1,7 @@
 # port for main server
 port := 5053
 moc_server_address := 127.0.0.1:5059
+
 bold := \033[1m
 normal := \033[0m
 good := \033[1m\033[0;32m
@@ -43,9 +44,6 @@ test-port-endpoint:
 build:
 	go build -o bin/simple-choose-ad cmd/main.go
 
-build-and-push:
-	@GOOS=linux GOARCH=amd64 go build -o build/ssp cmd/main.go && rsync -ah build/ssp ubuntu:~/ssp-testbed-clone/builds
-
 start-moc-server:
 	@echo "[!] Starting up moc-server on $(moc_server_address) ..."
 	@go run internal/moc_server.go -l $(moc_server_address) &

cmd/client_server/client.go

@@ -2,66 +2,45 @@ package clientserver
 
 import (
 	"bytes"
-	"context"
 	"encoding/json"
+	"errors"
+	"fmt"
 	"io/ioutil"
 	"log"
 	"math"
 	"net/http"
+	customtypes "sample-choose-ad/cmd/custom_types"
 	req_types "sample-choose-ad/cmd/requests_types"
-	"sync"
+	"sort"
 	"time"
 )
 
-func makeRequest(url string, body *[]byte, response chan<- []req_types.RespImp, wg *sync.WaitGroup) {
+func sendRequest(url string, body *[]byte) (req_types.SuccesResponse, error) {
-	defer wg.Done()
-
 	var pResp req_types.SuccesResponse
 
-	c := &http.Client{}
+	c := &http.Client{
+		Timeout: 200 * time.Millisecond,
+	}
 
-	ctx, cls := context.WithTimeout(context.Background(), time.Duration(200*time.Millisecond))
+	resp, err := c.Post(url, "application/json", bytes.NewReader(*body))
-	defer cls()
 
-	req, _ := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(*body))
-	resp, err := c.Do(req)
-	// not responding or timeout
 	if err != nil {
-		log.Println("Error when making request", err)
+		eText := fmt.Sprintf("Error: partner %v not responding", url)
-		return
+		return pResp, errors.New(eText)
 	}
 	defer resp.Body.Close()
 
-	// maybe say smth to client?
 	if resp.StatusCode == 204 {
-		log.Println("No content")
+		return pResp, errors.New("No content")
-		return
 	}
 
 	b, _ := ioutil.ReadAll(resp.Body)
-	log.Println(string(b))
+
-	if err := json.Unmarshal(b, &pResp); err != nil {
+	if json.Unmarshal(b, &pResp) != nil {
-		log.Println("Error: response unmarshalling", err)
+		log.Println(err)
-		return
 	}
 
-	// try to convert prices to float
+	return pResp, nil
-
-	// for _, imp := range pResp.Imp {
-	// 	// log.Printf("%v : %T", imp.PriceStr, imp.PriceStr)
-	// 	// imp.Price = imp.PriceStr.(float64)
-	// 	// switch imp.PriceStr.(type) {
-	// 	// case float64:
-	// 	// 	imp.Price = imp.PriceStr.(float64)
-	// 	// case string:
-	// 	// 	imp.Price, err = strconv.ParseFloat(imp.PriceStr.(string), 64)
-	// 	// 	if err != nil {
-	// 	// 		log.Println("Pasring price error, ", err)
-	// 	// 	}
-	// 	// }
-	// }
-
-	response <- pResp.Imp
 }
 
 // Create requset body based in incoming reqest `ir` and return
@@ -71,12 +50,12 @@ func constructPartnersRequestBody(ir *req_types.IncomingRequest) []byte {
 
 	var imps []req_types.Imp
 
+	// WARN: uint and float multiplication may cause problems
 	for _, tile := range ir.Tiles {
-		minheight := uint(math.Floor(float64(tile.Width) * tile.Ratio))
 		imps = append(imps, req_types.Imp{
 			Id:        tile.Id,
 			Minwidth:  tile.Width,
-			Minheight: minheight})
+			Minheight: uint(math.Floor(float64(tile.Width * uint(tile.Ratio))))})
 	}
 
 	outReqBody.Id = *ir.Id
@@ -85,3 +64,47 @@ func constructPartnersRequestBody(ir *req_types.IncomingRequest) []byte {
 	t, _ := json.Marshal(outReqBody)
 	return t
 }
+
+// map[imp.id]map[imp.id.price]
+type PartnersResponses map[uint]map[float64]req_types.RespImp
+
+// Make request for each partner and returns
+func makePartnersRequests(partners []customtypes.PartnersAddress, ir *req_types.IncomingRequest) {
+	p_body := constructPartnersRequestBody(ir)
+
+	// Two data structures:
+	// partnersRespones for getting price with O(1) complexity
+	// []prices as slice of actual prices
+	partnersRespones := make(map[uint]map[float64]req_types.RespImp)
+	prices := make(map[uint][]float64)
+
+	for _, p := range partners {
+		url := fmt.Sprintf("http://%v:%v/%v", p.Ip, p.Port, PARTNER_ENDPOINT)
+
+		re, err := sendRequest(url, &p_body)
+
+		if err != nil {
+			log.Println(err)
+			continue
+		}
+		// append only successful responses
+		for _, r := range re.Imp {
+			if partnersRespones[r.Id] == nil {
+				partnersRespones[r.Id] = make(map[float64]req_types.RespImp)
+			}
+			partnersRespones[r.Id][r.Price] = r
+			prices[r.Id] = append(prices[r.Id], r.Price)
+		}
+
+	}
+
+	if len(partnersRespones) == 0 {
+		log.Println("Error: no responses from partners.")
+		return
+	}
+
+	// Sorting prices, now biggest price at index len-1
+	for _, p := range prices {
+		sort.Float64s(p)
+	}
+}

cmd/client_server/handlers.go

@@ -9,7 +9,7 @@ import (
 	"net/http"
 	customtypes "sample-choose-ad/cmd/custom_types"
 	req_types "sample-choose-ad/cmd/requests_types"
-	"sync"
+	"sort"
 )
 
 const PARTNER_ENDPOINT = "bid_request"
@@ -48,10 +48,7 @@ func parseAndCheckIncomingRequest(w http.ResponseWriter, r *http.Request) (req_t
 	if wrongIPAddresFormat(inpReqBody.Context.Ip) {
 		return inpReqBody, throwHTTPError("WRONG_SCHEMA", 400, &w)
 	}
-	// UserAgent validation
+
-	if len(inpReqBody.Context.UserAgent) == 0 {
-		return inpReqBody, throwHTTPError("EMPTY_FIELD", 400, &w)
-	}
 	return inpReqBody, err
 }
 
@@ -69,65 +66,55 @@ func handleRequest(partners []customtypes.PartnersAddress) http.HandlerFunc {
 
 		p_body := constructPartnersRequestBody(&incReq)
 
-		wg := new(sync.WaitGroup)
+		// Two data structures:
-		responsesCh := make(chan []req_types.RespImp, len(partners))
+		// partnersRespones for getting price with O(1) complexity
-		var respImps []req_types.RespImp
+		// []prices as slice of actual prices
-		// Send requests to partners, collecting responses in `responses` channel
+		partnersRespones := make(PartnersResponses)
+		prices := make(map[uint][]float64)
+
 		for _, p := range partners {
-			wg.Add(1)
 			url := fmt.Sprintf("http://%v:%v/%v", p.Ip, p.Port, PARTNER_ENDPOINT)
-			go makeRequest(url, &p_body, responsesCh, wg)
-		}
-		wg.Wait()
-		close(responsesCh)
 
-		for r := range responsesCh {
+			re, err := sendRequest(url, &p_body)
-			respImps = append(respImps, r...)
+
-		}
+			if err != nil {
-		// У нас нет одинаковых пар цена и ид
+				log.Println(err)
-		partnersRespones := make(map[uint]req_types.RespImp)
-		for _, resp := range respImps {
-			if _, exist := partnersRespones[resp.Id]; !exist {
-				partnersRespones[resp.Id] = resp
 				continue
 			}
-
+			// append only successful responses
-			// Replase with new Imp, if last saved price smaller
+			for _, r := range re.Imp {
-			// Using type assertion, 'cause `Price` is interface
+				if partnersRespones[r.Id] == nil {
-			if partnersRespones[resp.Id].Price.(float64) < resp.Price.(float64) {
+					partnersRespones[r.Id] = make(map[float64]req_types.RespImp)
-				partnersRespones[resp.Id] = resp
+				}
+				partnersRespones[r.Id][r.Price] = r
+				prices[r.Id] = append(prices[r.Id], r.Price)
 			}
+
 		}
 
-		// { drop this
+		if len(partnersRespones) == 0 {
-		log.Println("respImps")
+			log.Println("Error: no responses from partners.")
-		for _, i := range respImps {
+			return
-			log.Printf("%v : %v", i.Id, i.Price)
 		}
 
-		log.Println("partnersRespones")
+		// Sorting prices, now biggest price at index len-1
-		for _, i := range partnersRespones {
+		for _, p := range prices {
-			log.Printf("%v : %v", i.Id, i.Price)
+			sort.Float64s(p)
 		}
-		// }
+
 		var bestOptions []req_types.RespImp
 
-		// tile.Id == RespImp.Id
 		// for each tile peak best price
 		for _, tile := range incReq.Tiles {
-			if val, exist := partnersRespones[tile.Id]; exist {
+			if len(prices[tile.Id]) == 0 {
-				bestOptions = append(bestOptions, val)
+				log.Println("No imp for tile ", tile.Id)
+				continue
 			}
-
+			last := len(prices[tile.Id]) - 1
+			biggestPrice := prices[tile.Id][last]
+			bestOptions = append(bestOptions, partnersRespones[tile.Id][biggestPrice])
 		}
 
-		// if len(bestOptions) == 0 {
-		// 	// log.Println("Error: no responses from partners.")
-		// 	log.Println("Error: No Content")
-		// 	w.WriteHeader(http.StatusNoContent)
-		// 	return
-		// }
-
 		response := req_types.SuccesResponse{
 			Id:  *incReq.Id,
 			Imp: bestOptions,

cmd/client_server/server.go

@@ -5,46 +5,11 @@ import (
 	"log"
 	"net/http"
 	customtypes "sample-choose-ad/cmd/custom_types"
-	"time"
 )
 
-const MAX_TIME_PER_REQUEST = time.Duration(250 * time.Millisecond)
-
-type customHandler struct {
-	Parners []customtypes.PartnersAddress
-	// context?
-}
-
-func (c *customHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	base := r.URL.Path
-
-	switch base {
-	case "/placements/request":
-
-	default:
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusBadRequest)
-	}
-}
-
-func newCustomHandler() *customHandler {
-	return &customHandler{}
-}
-
 func StartServer(port string, partners []customtypes.PartnersAddress) {
-	// mux := http.NewServeMux()
-	// mux.HandleFunc("/placements/request", handleRequest(partners))
 
-	// s := &http.Server{
+	http.HandleFunc("/placements/request", handleRequest(partners))
-	// 	ReadTimeout:  time.Duration(time.Millisecond * 20),
-	// 	WriteTimeout: time.Duration(time.Millisecond * 20),
-	// 	Handler:      newCustomHandler(),
-	// }
-	// s.ListenAndServe()
-	// h := http.HandleFunc("/placements/request", handleRequest(partners))
-	h := http.TimeoutHandler(handleRequest(partners), MAX_TIME_PER_REQUEST, "")
-	http.Handle("/placements/request", h)
-	// http.Handle("/placements/request", handleRequest(partners))
 	// http.HandleFunc("/placements/request", decorate(test2))
 
 	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%v", port), nil))

cmd/requests_types/response_type.go

@@ -1,14 +1,12 @@
 package req_types
 
-// Price is interface (but will be used as float64) 'cuz it can be quoted or unquoted
 type RespImp struct {
-	Id     uint   `json:"id"`
+	Id     uint    `json:"id"`
-	Width  uint   `json:"width"`
+	Width  uint    `json:"width"`
-	Height uint   `json:"height"`
+	Height uint    `json:"height"`
-	Title  string `json:"title"`
+	Title  string  `json:"title"`
-	Url    string `json:"url"`
+	Url    string  `json:"url"`
-	// Price expects as float64, but it may be quoted or unquoted
+	Price  float64 `json:"price,string"`
-	Price interface{} `json:"price"`
 }
 
 // Response from ad partners

internal/json/valid_response.json

@@ -2,7 +2,7 @@
   "id": "123",
   "imp": [
     {
-      "id": 1234,
+      "id": 123,
       "width": 144,
       "height": 122,
       "title": "example1",
@@ -10,20 +10,20 @@
       "price": 123.5
     },
     {
-      "id": 1234,
+      "id": 123,
       "width": 155,
       "height": 133,
       "title": "bestoption",
       "url": "bestoption.com",
-      "price": "143.8"
+      "price": 143.8
     },
     {
-      "id": 1234,
+      "id": 123,
       "width": 155,
       "height": 133,
       "title": "notabestoption",
       "url": "notabestoption.com",
-      "price": 110.8
+      "price": 100.8
     }
   ]
 }

internal/moc_server.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"flag"
-	"io/ioutil"
 	"log"
 	"net/http"
 	"os"
@@ -21,8 +20,8 @@ func main() {
 	}
 
 	http.HandleFunc("/bid_request", func(w http.ResponseWriter, r *http.Request) {
-		inc, _ := ioutil.ReadAll(r.Body)
+		// b, _ := ioutil.ReadAll(r.Body)
-		log.Println(string(inc))
+		// log.Println(string(b))
 		w.Header().Add("Content-Type", "application/json")
 		w.Write(file)
 	})