Пример #1
0
func main() {

	const (
		URLRecord = "/a8/record"
		URLVerify = "/a8/verify"
	)

	myAddrStr := flag.String("myaddr", "localhost:9002", "Address to listen on")
	a8AddrStr := flag.String("a8addr", "localhost:9003", "Address of A8 scheduler")
	flag.Parse()

	versionStr := "Mock A8 Scheduler Test"
	serverSetup := httpctxserver.HTTPServerSetup{AddrStr: *myAddrStr, VersionStr: versionStr}

	//Subscribe to Mock A8 scheduler
	var subscribeReq = comdef.SubscribeReq{
		RequestID:         "c4646160-6448-11df-9c5e-0050569339e3",
		RecordingLocality: "mile-high",
		MaxEntries:        10,
		RecordURL:         "http://" + *myAddrStr + URLRecord,
		VerifyURL:         "http://" + *myAddrStr + URLVerify,
	}
	var subscribeResp comdef.SubscribeResp

	httpStatus, err := httputilfuncs.PostHTTPJSONString("http://"+*a8AddrStr+comdef.URLSubscribe,
		subscribeReq, &subscribeResp, timeOut)

	if err != nil {
		log.Printf("Failed on Subscribe request! err:%v\n", err)
		return
	}

	log.Printf("HttpStatus: %d, resp: %v", httpStatus, subscribeResp)

	if httpStatus != http.StatusOK {
		log.Printf("HttpStatus is not ok, exit")
		return
	}

	if subscribeResp.RequestID != subscribeReq.RequestID {
		log.Printf("Resp.RequstID: %s is not same as Req.RequestID: %s", subscribeResp.RequestID, subscribeReq.RequestID)
	}

	a8VerifyURL = subscribeResp.VerifyURL

	mockScheduler := httpctxserver.NewHTTPServer(serverSetup)

	//Add handler
	mockScheduler.AddHandler(URLRecord, handleRecord)
	mockScheduler.AddHandler(URLVerify, handleVerify)

	//Start go routine to send update and verify request
	go sendUpdateAndVerify(dataChan, doneChan)

	//Start Server
	mockScheduler.Start()

}
Пример #2
0
func recordReq() {

	req := getrecPayload()
	resp := comdef.RecordResp{}
	httpStatus, err := httputilfuncs.PostHTTPJSONString(recordURL,
		req, &resp, 10*time.Second)

	if err != nil {
		log.Printf("Failed on send Record request! err:%v\n", err)
		return
	}

	log.Printf("Http Status: %d, resp: %v", httpStatus, resp)

}
Пример #3
0
// Test - A good Set Recording Message
func testSetRecordingsHappyPath() error {

	var statusCode int

	// Make sure A8 test server is ready and there is no error
	a8Status, err := checkA8TestServerStatus()
	if err != nil {
		return err
	}

	// ------ TEST HAPPY PATH ------
	// Now we really set everything to DB, this should be successful!
	testRecs := createTestRecEntries(a8Status.MaxEntriesToRM)

	statusCode, _, err = setRecordings(a8Status.RecordURL, testRecs)
	if err != nil {
		return fmt.Errorf("SetRecording, failed, err:%v", err)
	}
	if statusCode != http.StatusNoContent {
		return fmt.Errorf("SetRecording, expect http status code: %d, got: %d", http.StatusNoContent, statusCode)
	}

	// Read Back from Mock Metadata Service
	var resp recordingtbl.RespRecRead
	for _, rec := range testRecs {
		req := recordingtbl.ReqRecRead{
			ReadType: recordingtbl.ReadRecByXRID,
			XRID:     rec.RecordingID,
		}

		statusCode, err = httputilfuncs.PostHTTPJSONString(dbServerURL+recordingtbl.URLRecRead, &req, &resp, 2*time.Second)
		if err != nil {
			return fmt.Errorf("SetRecording, failed to read Recording from Mock MetaData, err:%v", err)
		}
		if statusCode != http.StatusOK {
			return fmt.Errorf("SetRecording, failed to read Recording from Mock MetaData, got http status code: %d", statusCode)
		}
		if len(resp.Recordings) != 1 {
			return fmt.Errorf("SetRecording, recording with XRID:%s is not found in Mock MetaData", rec.RecordingID)
		}
	} // for

	return nil
}
Пример #4
0
func setRecording(recordURL string, req comdef.RecordReq) (int, comdef.RecordResp, error) {

	resp := comdef.RecordResp{}

	statusCode, err := httputilfuncs.PostHTTPJSONString(recordURL, req, &resp, 10*time.Second)
	if err != nil {
		return statusCode, resp, err
	}

	if statusCode == http.StatusOK {
		if resp.RequestID != req.RequestID {
			return statusCode, resp, fmt.Errorf("Mismatch Request ID, received:%s, should be: %s", resp.RequestID, req.RequestID)
		}

		return statusCode, resp, nil
	}

	return statusCode, resp, nil
}
func upsertRecToDB(recUpdate recordingtbl.RecUpdate) (uint64, error) {
	var (
		req        recordingtbl.ReqUpdateRec
		resp       recordingtbl.RespUpdateRec
		statusCode int
		err        error
	)

	req.Entries = append(req.Entries, recUpdate)
	statusCode, err = httputilfuncs.PostHTTPJSONString(dbServerURL+recordingtbl.URLUpsert, &req, &resp, 2*time.Second)
	if err != nil {
		return 0, fmt.Errorf("Failed on upsert recording to Mock MetaData, err:%v", err)
	}
	if statusCode != http.StatusOK {
		return 0, fmt.Errorf("Failed on upsert recording to Mock MetaData, got http status code: %d", statusCode)
	}
	if len(resp.Entries) != len(req.Entries) {
		return 0, fmt.Errorf("Failed on upsert recording to Mock MetaData, expect %d entries return, got %d", len(req.Entries), len(resp.Entries))
	}

	return resp.Entries[0].IRID, nil
}
Пример #6
0
func setRecordings(recordURL string, recEntries []*record.RecEntry) (int, []*a8common.RespObject, error) {
	var resp record.Response

	req := record.Request{
		RequestID: fmt.Sprintf("Req-%d", time.Now().UnixNano()),
		Entries:   recEntries,
	}

	statusCode, err := httputilfuncs.PostHTTPJSONString(recordURL, &req, &resp, 2*time.Second)
	if err != nil {
		return statusCode, nil, err
	}

	if statusCode == http.StatusOK {
		if resp.RequestID != req.RequestID {
			return statusCode, nil, fmt.Errorf("Mismatch Request ID, received:%s, should be: %s", resp.RequestID, req.RequestID)
		}

		return statusCode, resp.Entries, nil
	}

	return statusCode, nil, nil
}
Пример #7
0
func testUpdateMessage() error {

	restartA8Server()
	a8Status := getA8ServerStatus()
	if a8Status == nil {
		return fmt.Errorf("A8 Server is not ready")
	}
	if a8Status.Err != nil {
		return fmt.Errorf("A8 Server is in Error State: %v", a8Status.Err)
	}

	// We will create some recordings first
	req := getrecPayload(1, a8Status.MaxEntriesFromRM) //1*30 second recordings
	recDataGlb = req.Entries
	statusCode, _, err := setRecording(a8Status.RecordURL, req)

	if err != nil {
		return fmt.Errorf("SetRecording, failed, err:%v", err)
	}
	if statusCode != http.StatusNoContent {
		return fmt.Errorf("SetRecording, expect http status code: %d, got: %d", http.StatusNoContent, statusCode)
	}
	fmt.Println("---Waiting for recording to be Started---")
	time.Sleep(20 * time.Second)

	a8Status = getA8ServerStatus()
	if a8Status == nil {
		return fmt.Errorf("A8 Server is not ready")
	}
	if a8Status.Err != nil {
		return fmt.Errorf("A8 Server is in Error State: %v", a8Status.Err)
	}

	if len(a8Status.UpdateEntries) != len(req.Entries) {
		fmt.Println("Failing here")
		return fmt.Errorf("Expect %d status obj in update message test, got %d", len(req.Entries), len(a8Status.UpdateEntries))
	}

	for _, ent := range a8Status.UpdateEntries {
		if ent.Status != "STARTED" {
			return fmt.Errorf("For recording with XRID:%s, status is %s, should be STARTED", ent.RecordingID, ent.Status)
		}
	}

	// Read it back from Mock Data to make sure RMNotified is set to true
	var mdRespStart recordingtbl.RespRecRead
	for _, rec := range recDataGlb {
		mdReq := recordingtbl.ReqRecRead{
			ReadType: recordingtbl.ReadRecByXRID,
			XRID:     rec.RecordingID,
		}

		statusCode, err = httputilfuncs.PostHTTPJSONString(dbServerURL+recordingtbl.URLRecRead, &mdReq, &mdRespStart, 2*time.Second)
		if err != nil {
			return fmt.Errorf("UpdateMessage, failed to read Recording from Mock MetaData, err:%v", err)
		}
		if statusCode != http.StatusOK {
			return fmt.Errorf("UpdateMessage, failed to read Recording from Mock MetaData, got http status code: %d", statusCode)
		}
		if len(mdRespStart.Recordings) != 1 {
			return fmt.Errorf("UpdateMessage, recording with XRID:%s is not found in Mock MetaData", mdReq.XRID)
		}
		if mdRespStart.Recordings[0].XRID != mdReq.XRID {
			return fmt.Errorf("UpdateMessage, got resp for XRID:%s, not %s", mdRespStart.Recordings[0].XRID, mdReq.XRID)
		}
		if mdRespStart.Recordings[0].RMNotified != true {
			return fmt.Errorf("UpdateMessage, got resp for XRID:%s, RMNotified is not set to true", mdReq.XRID)
		}
	}

	//Wait for the recording to be completed
	fmt.Println("---Waiting for recording to be completed---")
	time.Sleep(30 * time.Second)

	a8Status = getA8ServerStatus()
	if a8Status == nil {
		return fmt.Errorf("A8 Server is not ready")
	}
	if a8Status.Err != nil {
		return fmt.Errorf("A8 Server is in Error State: %v", a8Status.Err)
	}

	exp_updt_entries := len(req.Entries) * 2 //Expecting update entries for START AND COMPLETE
	if len(a8Status.UpdateEntries) != exp_updt_entries {
		return fmt.Errorf("Expect %d status obj in update message, got %d", exp_updt_entries, len(a8Status.UpdateEntries))
	}
	a8_exp_status := []string{"STARTED", "COMPLETE"} //Setting the expected A8 status to be STARTED and COMPLETE
	i := 0
	for _, ent := range a8Status.UpdateEntries {
		if ent.Status != a8_exp_status[i] {
			return fmt.Errorf("For recording with XRID:%s, status is %s, should be %s", ent.RecordingID, ent.Status, a8_exp_status[i])
		}
		i = i + 1
	}

	// Read it back from Mock Data to make sure RMNotified is set to true
	var mdRespComp recordingtbl.RespRecRead
	for _, rec := range recDataGlb {
		mdReq := recordingtbl.ReqRecRead{
			ReadType: recordingtbl.ReadRecByXRID,
			XRID:     rec.RecordingID,
		}

		statusCode, err = httputilfuncs.PostHTTPJSONString(dbServerURL+recordingtbl.URLRecRead, &mdReq, &mdRespComp, 2*time.Second)
		if err != nil {
			return fmt.Errorf("UpdateMessage, failed to read Recording from Mock MetaData, err:%v", err)
		}
		if statusCode != http.StatusOK {
			return fmt.Errorf("UpdateMessage, failed to read Recording from Mock MetaData, got http status code: %d", statusCode)
		}
		if len(mdRespComp.Recordings) != 1 {
			return fmt.Errorf("UpdateMessage, recording with XRID:%s is not found in Mock MetaData", mdReq.XRID)
		}
		if mdRespComp.Recordings[0].XRID != mdReq.XRID {
			return fmt.Errorf("UpdateMessage, got resp for XRID:%s, not %s", mdRespComp.Recordings[0].XRID, mdReq.XRID)
		}
		if mdRespComp.Recordings[0].RMNotified != true {
			return fmt.Errorf("UpdateMessage, got resp for XRID:%s, RMNotified is not set to true", mdReq.XRID)
		}
	}

	return nil
}
Пример #8
0
func sendUpdateAndVerify(dataChan <-chan comdef.RecordData, doneChan chan<- byte) {

	quit := false

	pendingUpdateList := []updateData{}
	pendingVerifyList := []updateData{}

	for !quit {

		select {

		case data := <-dataChan:
			statusObject := comdef.StatusObject{Status: "UNKNOWN",
				RecordingID:   data.RecordingID,
				ScheduledTime: data.ScheduledTime,
				SegmentCount:  0,
			}
			updataData := updateData{StatusObj: statusObject, RecordObj: data}
			pendingUpdateList = append(pendingUpdateList, updataData)

			break
		case <-time.After(time.Second * 1):
			if len(pendingVerifyList) > 0 {
				verifyReq := comdef.VerifyReq{RequestID: fmt.Sprintf("r12345678-1234-aaaa-bbbb-%d", time.Now().Unix()),
					Entries: []comdef.VerifyReqData{}}

				for _, obj := range pendingVerifyList {
					verifyData := comdef.VerifyReqData{RecordingID: obj.RecordObj.RecordingID}
					verifyReq.Entries = append(verifyReq.Entries, verifyData)
				}

				//send verify req, we assume all status Obj has the same update URL for now
				log.Printf("Sending Verify Request: req:%v", verifyReq)
				verifyResp := comdef.VerifyResp{}
				httpStatus, err := httputilfuncs.PostHTTPJSONString(a8VerifyURL, verifyReq, &verifyResp, timeOut)
				if err != nil {
					log.Printf("Error when sending Update Request, err: %v", err)
				} else {
					log.Printf("HttpStatus: %d, Resp: %v", httpStatus, verifyResp)
				}

				//clear list for gc
				pendingVerifyList = []updateData{}
			}

			if len(pendingUpdateList) > 0 {
				updateReq := comdef.UpdateReq{RequestID: fmt.Sprintf("r12345678-1234-cccc-dddd-%d", time.Now().Unix()),
					Entries: []comdef.StatusObject{}}
				for _, obj := range pendingUpdateList {
					updateReq.Entries = append(updateReq.Entries, obj.StatusObj)
				}
				//send update req, we assume all status Obj has the same update URL for now
				log.Printf("1 -- Sending Update Request: req:%v", updateReq)
				updateResp := comdef.UpdateResp{}
				fmt.Println(pendingUpdateList[0].RecordObj.UpdateURL)
				httpStatus, err := httputilfuncs.PostHTTPJSONString(pendingUpdateList[0].RecordObj.UpdateURL, updateReq, &updateResp, timeOut)
				if err != nil {
					log.Printf("Error when sending Update Request, err: %v", err)
				} else {
					log.Printf("HttpStatus: %d, Resp: %v", httpStatus, updateResp)
				}

				//clear list for gc
				pendingVerifyList = pendingUpdateList
				pendingUpdateList = []updateData{}
			}
			break
		} //end switch
	} //end for

	doneChan <- 1
}
Пример #9
0
func teststopRecordings() error {

	restartA8Server()
	a8Status, err := checkA8TestServerStatus1()
	if err != nil {
		return err
	}

	//Sending request to start a recording and validate the STARTED update message from RM
	req := getrecPayload(5, 1) //5*30 second 1 recording will be created
	recDataGlb = req.Entries

	statusCode, _, err := setRecording(a8Status.RecordURL, req)

	if err != nil {
		return fmt.Errorf("SetRecording, failed, err:%v", err)
	}
	if statusCode != http.StatusNoContent {
		return fmt.Errorf("SetRecording, expect http status code: %d, got: %d", http.StatusNoContent, statusCode)
	}
	fmt.Println("---Waiting for recording to be Started---")
	time.Sleep(25 * time.Second)

	a8Status = getA8ServerStatus()
	resp, err := http.Get("http://localhost:9003/updateClient")
	if err != nil {
		// handle error
	}
	defer resp.Body.Close()
	fmt.Println(resp)
	body, err := ioutil.ReadAll(resp.Body)
	var data A8ServerStatus
	fmt.Println(body)
	err1 := json.Unmarshal(body, &data)
	fmt.Println(data)
	if err1 != nil {
		fmt.Println(err1)
	}

	if a8Status == nil {
		return fmt.Errorf("A8 Server is not ready")
	}
	if a8Status.Err != nil {
		return fmt.Errorf("A8 Server is in Error State: %v", a8Status.Err)
	}

	if len(a8Status.UpdateEntries) != len(req.Entries) {
		return fmt.Errorf("Expect %d status obj in update message, got %d", len(req.Entries), len(a8Status.UpdateEntries))
	}

	for _, ent := range a8Status.UpdateEntries {
		if ent.Status != "STARTED" {
			return fmt.Errorf("For recording with XRID:%s, status is %s, should be STARTED", ent.RecordingID, ent.Status)
		}
	}

	//Sending request to stop recording and validatin the COMPLETE update message from RM
	nowTime := time.Now()
	req.Entries[0].EndTime = nowTime.Format(comdef.TimeFrmtStr)

	statusCode1, _, err1 := setRecording(a8Status.RecordURL, req)

	if err1 != nil {
		return fmt.Errorf("SetRecording, failed, err:%v", err)
	}
	if statusCode1 != http.StatusNoContent {
		return fmt.Errorf("SetRecording, expect http status code: %d, got: %d", http.StatusNoContent, statusCode1)
	}

	fmt.Println("---Waiting for recording to be Stopped---")
	time.Sleep(15 * time.Second)

	a8Status = getA8ServerStatus()

	if a8Status == nil {
		return fmt.Errorf("A8 Server is not ready")
	}
	if a8Status.Err != nil {
		return fmt.Errorf("A8 Server is in Error State: %v", a8Status.Err)
	}

	exp_updt_entries := len(req.Entries) * 2 //Expecting update entries for START AND COMPLETE
	if len(a8Status.UpdateEntries) != exp_updt_entries {
		return fmt.Errorf("Expect %d status obj in update message, got %d", exp_updt_entries, len(a8Status.UpdateEntries))
	}

	a8_exp_status := []string{"STARTED", "COMPLETE"}
	i := 0
	for _, ent := range a8Status.UpdateEntries {
		if ent.Status != a8_exp_status[i] {
			return fmt.Errorf("For recording with XRID:%s, status is %s, should be %s", ent.RecordingID, ent.Status, a8_exp_status[i])
		}
		i = i + 1
	}

	// Read it back from Mock Data to make sure EndTime matches the one we send in stop request
	var mdResp recordingtbl.RespRecRead
	for _, rec := range recDataGlb {
		mdReq := recordingtbl.ReqRecRead{
			ReadType: recordingtbl.ReadRecByXRID,
			XRID:     rec.RecordingID,
		}

		statusCode, err = httputilfuncs.PostHTTPJSONString(dbServerURL+recordingtbl.URLRecRead, &mdReq, &mdResp, 2*time.Second)
		if err != nil {
			return fmt.Errorf("UpdateMessage, failed to read Recording from Mock MetaData, err:%v", err)
		}
		if statusCode != http.StatusOK {
			return fmt.Errorf("UpdateMessage, failed to read Recording from Mock MetaData, got http status code: %d", statusCode)
		}
		if len(mdResp.Recordings) != 1 {
			return fmt.Errorf("UpdateMessage, recording with XRID:%s is not found in Mock MetaData", mdReq.XRID)
		}
		if mdResp.Recordings[0].XRID != mdReq.XRID {
			return fmt.Errorf("UpdateMessage, got resp for XRID:%s, not %s", mdResp.Recordings[0].XRID, mdReq.XRID)
		}
		t := mdResp.Recordings[0].EndTime.Format(a8common.ISO8601FmtStr)

		if t != req.Entries[0].EndTime {
			return fmt.Errorf("UpdateMEssage, got resp for XRID:%s, EndTime is not matching", mdReq.XRID)
		}
	}

	return nil

}
Пример #10
0
func testdelRecordings() error {

	restartA8Server()
	a8Status, err := checkA8TestServerStatus1()
	if err != nil {
		return err
	}

	//Sending request to start a recording and validate the STARTED update message from RM
	req := getrecPayload(5, 1) //5*30 second 1 recording will be created
	delDataGlb = req.Entries

	statusCode, _, err := setRecording(a8Status.RecordURL, req)

	if err != nil {
		return fmt.Errorf("SetRecording, failed, err:%v", err)
	}
	if statusCode != http.StatusNoContent {
		return fmt.Errorf("SetRecording, expect http status code: %d, got: %d", http.StatusNoContent, statusCode)
	}
	fmt.Println("---Waiting for recording to be Started---")
	time.Sleep(20 * time.Second)

	a8Status = getA8ServerStatus()

	if a8Status == nil {
		return fmt.Errorf("A8 Server is not ready")
	}
	if a8Status.Err != nil {
		return fmt.Errorf("A8 Server is in Error State: %v", a8Status.Err)
	}

	if len(a8Status.UpdateEntries) != len(req.Entries) {
		return fmt.Errorf("Expect %d status obj in update message, got %d", len(req.Entries), len(a8Status.UpdateEntries))
	}

	for _, ent := range a8Status.UpdateEntries {
		if ent.Status != "STARTED" {
			return fmt.Errorf("For recording with XRID:%s, status is %s, should be STARTED", ent.RecordingID, ent.Status)
		}
	}

	//Sending request to Delete recording
	delReq := getdelPayload()

	statusCode1, _, err1 := setRecording(a8Status.RecordURL, delReq)

	if err1 != nil {
		return fmt.Errorf("SetRecording, failed, err:%v", err)
	}
	if statusCode1 != http.StatusNoContent {
		return fmt.Errorf("SetRecording, expect http status code: %d, got: %d", http.StatusNoContent, statusCode1)
	}

	fmt.Println("---Waiting for recording to be Deleted---")
	time.Sleep(5 * time.Second)

	a8Status = getA8ServerStatus()

	if a8Status == nil {
		return fmt.Errorf("A8 Server is not ready")
	}
	if a8Status.Err != nil {
		return fmt.Errorf("A8 Server is in Error State: %v", a8Status.Err)
	}

	exp_updt_entries := len(req.Entries) * 2 //Expecting update entries for START AND COMPLETE
	if len(a8Status.UpdateEntries) != exp_updt_entries {
		return fmt.Errorf("Expect %d status obj in update message, got %d", exp_updt_entries, len(a8Status.UpdateEntries))
	}

	a8_exp_status := []string{"STARTED", "COMPLETE"}
	i := 0
	for _, ent := range a8Status.UpdateEntries {
		if ent.Status != a8_exp_status[i] {
			return fmt.Errorf("For recording with XRID:%s, status is %s, should be %s", ent.RecordingID, ent.Status, a8_exp_status[i])
		}
		i = i + 1
	}

	// Read it back from Mock Data to make sure Erased time is updated in the table
	var mdResp recordingtbl.RespRecRead
	for _, rec := range delDataGlb {
		mdReq := recordingtbl.ReqRecRead{
			ReadType: recordingtbl.ReadRecByXRID,
			XRID:     rec.RecordingID,
		}

		statusCode, err = httputilfuncs.PostHTTPJSONString(dbServerURL+recordingtbl.URLRecRead, &mdReq, &mdResp, 2*time.Second)
		if err != nil {
			return fmt.Errorf("UpdateMessage, failed to read Recording from Mock MetaData, err:%v", err)
		}
		if statusCode != http.StatusOK {
			return fmt.Errorf("UpdateMessage, failed to read Recording from Mock MetaData, got http status code: %d", statusCode)
		}
		if len(mdResp.Recordings) != 1 {
			return fmt.Errorf("UpdateMessage, recording with XRID:%s is not found in Mock MetaData", mdReq.XRID)
		}
		if mdResp.Recordings[0].XRID != mdReq.XRID {
			return fmt.Errorf("UpdateMessage, got resp for XRID:%s, not %s", mdResp.Recordings[0].XRID, mdReq.XRID)
		}

		erased_time := mdResp.Recordings[0].ErasedTime.Format(a8common.ISO8601FmtStr)
		if erased_time == "" {
			return fmt.Errorf("UpdateMEssage, got resp for XRID:%s, ErasedTime is not updated", mdReq.XRID)
		}
		actual_end_time := mdResp.Recordings[0].ActualEndTime.Format(a8common.ISO8601FmtStr)
		if actual_end_time == "" {
			return fmt.Errorf("UpdateMEssage, got resp for XRID:%s, Actual EndTime is not updated", mdReq.XRID)
		}
	}

	return nil
}