MySQL>> archiveservice>> 返回
项目作者： etiennelndr

项目描述 ：
CCSDS MO MAL GO SERVICE
高级语言： Go
项目地址: git://github.com/etiennelndr/archiveservice.git
创建时间： 2018-03-09T15:35:09Z
项目社区：https://github.com/etiennelndr/archiveservice
开源协议：MIT License
下载


MAL GO ARCHIVE SERVICE

Introduction

This service is an implementation of the Archive Service described in the CCSDS Recommendation Mission Operations Common Object Model CCSDS 521.1-B-1. It uses the High level MAL GO API available here.

Download this repository

  1. go get github.com/juju/loggo
  2. go get github.com/ccsdsmo/malgo
  3. go get github.com/etiennelndr/archiveservice

Using the Archive Service

If you want to see the Archive Service in action, click here and run this project.

Use of the provider

  1. // Variable that defines the ArchiveService
  2. var archiveService *ArchiveService
  3. // Variable to retrieve the error
  4. var err error
  5. // Create the Archive Service
  6. archiveService = archiveService.CreateService().(*ArchiveService)
  8. // Start the providers
  9. err = archiveService.StartProvider("maltcp://127.0.0.1:12400")
  11. if err != nil {
  12.     fmt.Println("Error:", err)
  13. }

Use of the consumer

Retrieve

The retrieve operation retrieves a set of objects identified by their object instance identifier. In our service it can be used in that way:

  1. // Variable that defines the ArchiveService
  2. var archiveService *ArchiveService
  3. // Create the Archive Service
  4. service := archiveService.CreateService()
  5. archiveService = service.(*ArchiveService)
  6. // Variable that defines the ArchiveService
  7. var objectType = ObjectType{
  8.     Area:    UShort(2),
  9.     Service: UShort(3),
  10.     Version: UOctet(1),
  11.     Number:  UShort(COM_VALUE_OF_SINE_TYPE_SHORT_FORM),
  12. }
  13. var identifierList = IdentifierList([]*Identifier{NewIdentifier("fr"), NewIdentifier("cnes"), NewIdentifier("archiveservice"), NewIdentifier("test")})
  14. var longList = LongList([]*Long{NewLong(0)})
  16. // Variables to retrieve the return of this function
  17. var archiveDetailsList *ArchiveDetailsList
  18. var elementList ElementList
  19. var errorsList *ServiceError
  20. var err error
  22. // Start the consumer
  23. archiveDetailsList, elementList, errorsList, err = archiveService.Retrieve(consumerURL, providerURL, objectType, identifierList, longList)
  25. // Check errors
  26. if err != nil {
  27.     // Do Something
  28. } else if errorsList != nil {
  29.     // Do something else
  30. }

Query

The query operation retrieves a set of object instance identifiers, and optionally the object
bodies, from a list of supplied queries. The PROGRESS interaction pattern is used as the
returned set of data may be quite large and this allows it to be split over several MAL
messages. A simple way to use this operation:

  1. // Variable that defines the ArchiveService
  2. var archiveService *ArchiveService
  3. // Create the Archive Service
  4. service := archiveService.CreateService()
  5. archiveService = service.(*ArchiveService)
  7. // Create parameters
  8. var boolean = NewBoolean(true)
  9. var objectType = ObjectType{
  10.     Area:    UShort(2),
  11.     Service: UShort(3),
  12.     Version: UOctet(1),
  13.     Number:  UShort(COM_VALUE_OF_SINE_TYPE_SHORT_FORM),
  14. }
  15. archiveQueryList := NewArchiveQueryList(0)
  16. //var domain = IdentifierList([]*Identifier{NewIdentifier("fr"), NewIdentifier("cnes"), NewIdentifier("archiveservice"), NewIdentifier("test")})
  17. archiveQuery := &ArchiveQuery{
  18.     Related:   Long(0),
  19.     SortOrder: NewBoolean(true),
  20. }
  21. archiveQueryList.AppendElement(archiveQuery)
  22. var queryFilterList *CompositeFilterSetList
  24. // Variables to retrieve the return of this function
  25. var responses []interface{}
  26. var errorsList *ServiceError
  27. var err error
  28. // Start the consumer
  29. responses, errorsList, err = archiveService.Query(consumerURL, providerURL, boolean, objectType, *archiveQueryList, queryFilterList)
  31. // Check errors
  32. if err != nil {
  33.     // Do Something
  34. } else if errorsList != nil {
  35.     // Do something else
  36. }

Count

The count operation counts the set of objects based on a supplied query.

  1. // Variable that defines the ArchiveService
  2. var archiveService *ArchiveService
  3. // Create the Archive Service
  4. service := archiveService.CreateService()
  5. archiveService = service.(*ArchiveService)
  7. var objectType = &ObjectType{
  8.     Area:    UShort(2),
  9.     Service: UShort(3),
  10.     Version: UOctet(1),
  11.     Number:  UShort(COM_VALUE_OF_SINE_TYPE_SHORT_FORM),
  12. }
  13. archiveQueryList := NewArchiveQueryList(0)
  14. var domain = IdentifierList([]*Identifier{NewIdentifier("fr"), NewIdentifier("cnes"), NewIdentifier("archiveservice"), NewIdentifier("test")})
  15. archiveQuery := &ArchiveQuery{
  16.     Domain:    &domain,
  17.     Related:   Long(0),
  18.     SortOrder: NewBoolean(true),
  19. }
  20. archiveQueryList.AppendElement(archiveQuery)
  21. var queryFilterList *CompositeFilterSetList
  23. // Variable to retrieve the return of this function
  24. var longList *LongList
  25. var errorsList *ServiceError
  26. var err error
  27. // Start the consumer
  28. longList, errorsList, err = archiveService.Count(consumerURL, providerURL, objectType, archiveQueryList, queryFilterList)
  30. // Check errors
  31. if err != nil {
  32.     // Do Something
  33. } else if errorsList != nil {
  34.     // Do something else
  35. }

Store

The store operation stores new objects in the archive and causes an ObjectStored event to be
published by the archive.

When new objects are being stored in an archive by a service provider the archive service
provider is capable of allocating an unused object instance identifier for the objects being
stored. The returned object instance identifier should be used by the service provider for
identifying the object instances to its consumer to ensure that only a single object instance
identifier is used for each object instance.

In our case, this operation can be used in that way:

  1. // Variable that defines the ArchiveService
  2. var archiveService *ArchiveService
  3. // Create the Archive Service
  4. service := archiveService.CreateService()
  5. archiveService = service.(*ArchiveService)
  7. // Start the store consumer
  8. // Create parameters
  9. // Object that's going to be stored in the archive
  10. var elementList = NewValueOfSineList(1)
  11. (*elementList)[0] = NewValueOfSine(0)
  12. var boolean = NewBoolean(true)
  13. var objectType = ObjectType{
  14.     Area:    UShort(2),
  15.     Service: UShort(3),
  16.     Version: UOctet(1),
  17.     Number:  UShort(COM_VALUE_OF_SINE_TYPE_SHORT_FORM),
  18. }
  19. var identifierList = IdentifierList([]*Identifier{NewIdentifier("fr"), NewIdentifier("cnes"), NewIdentifier("archiveservice")})
  20. // Object instance identifier
  21. var objectInstanceIdentifier = *NewLong(81)
  22. // Variables for ArchiveDetailsList
  23. var objectKey = ObjectKey{
  24.     Domain: identifierList,
  25.     InstId: objectInstanceIdentifier,
  26. }
  27. var objectID = ObjectId{
  28.     Type: &objectType,
  29.     Key:  &objectKey,
  30. }
  31. var objectDetails = ObjectDetails{
  32.     Related: NewLong(1),
  33.     Source:  &objectID,
  34. }
  35. var network = NewIdentifier("network")
  36. var timestamp = NewFineTime(time.Now())
  37. var provider = NewURI("main/start")
  38. var archiveDetailsList = ArchiveDetailsList([]*ArchiveDetails{NewArchiveDetails(objectInstanceIdentifier, objectDetails, network, timestamp, provider)})
  40. // Variable to retrieve the return of this function
  41. var longList *LongList
  42. var err error
  43. var errorsList *ServiceError
  44. // Start the consumer
  45. longList, errorsList, err = archiveService.Store(consumerURL, providerURL, boolean, objectType, identifierList, archiveDetailsList, elementList)
  47. // Check errors
  48. if err != nil {
  49.     // Do Something
  50. } else if errorsList != nil {
  51.     // Do something else
  52. }

Update

The update operation updates an object (or set of objects) and causes an ObjectUpdated event
to be published by the archive.

  1. // Variable that defines the ArchiveService
  2. var archiveService *ArchiveService
  3. // Create the Archive Service
  4. service := archiveService.CreateService()
  5. archiveService = service.(*ArchiveService)
  7. // Start the update consumer
  8. // Create parameters
  9. // ---- ELEMENTLIST ----
  10. // Object that's going to be updated in the archive
  11. var elementList = NewValueOfSineList(1)
  12. (*elementList)[0] = NewValueOfSine(0.5)
  13. // ---- OBJECTTYPE ----
  14. var objectType = ObjectType{
  15.     Area:    UShort(2),
  16.     Service: UShort(3),
  17.     Version: UOctet(1),
  18.     Number:  UShort((*elementList)[0].GetTypeShortForm()),
  19. }
  20. // ---- IDENTIFIERLIST ----
  21. var identifierList = IdentifierList([]*Identifier{NewIdentifier("fr"), NewIdentifier("cnes"), NewIdentifier("archiveservice"), NewIdentifier("test")})
  22. // Object instance identifier
  23. var objectInstanceIdentifier = *NewLong(1)
  24. // Variables for ArchiveDetailsList
  25. // ---- ARCHIVEDETAILSLIST ----
  26. var objectKey = ObjectKey{
  27.     Domain: identifierList,
  28.     InstId: objectInstanceIdentifier,
  29. }
  30. var objectID = ObjectId{
  31.     Type: &objectType,
  32.     Key:  &objectKey,
  33. }
  34. var objectDetails = ObjectDetails{
  35.     Related: NewLong(1),
  36.     Source:  &objectID,
  37. }
  38. var network = NewIdentifier("new.network")
  39. var fineTime = NewFineTime(time.Now())
  40. var uri = NewURI("main/start")
  41. var archiveDetailsList = ArchiveDetailsList([]*ArchiveDetails{NewArchiveDetails(objectInstanceIdentifier, objectDetails, network, fineTime, uri)})
  43. // Variable to retrieve the return of this function
  44. var errorsList *ServiceError
  45. var err error
  46. // Start the consumer
  47. errorsList, err = archiveService.Update(consumerURL, providerURL, objectType, identifierList, archiveDetailsList, elementList)
  49. // Check errors
  50. if err != nil {
  51.     // Do Something
  52. } else if errorsList != nil {
  53.     // Do something else
  54. }

Delete

The delete operation deletes an object (or set of objects) and causes an ObjectDeleted event
to be published by the archive. A simple way to use this operation:

  1. // Variable that defines the ArchiveService
  2. var archiveService *ArchiveService
  3. // Create the Archive Service
  4. service := archiveService.CreateService()
  5. archiveService = service.(*ArchiveService)
  7. var objectType = ObjectType{
  8.     Area:    UShort(2),
  9.     Service: UShort(3),
  10.     Version: UOctet(1),
  11.     Number:  UShort(COM_VALUE_OF_SINE_TYPE_SHORT_FORM),
  12. }
  13. var identifierList = IdentifierList([]*Identifier{NewIdentifier("fr"), NewIdentifier("cnes"), NewIdentifier("archiveservice"), NewIdentifier("test")})
  14. var longList = NewLongList(0)
  15. longList.AppendElement(NewLong(15))
  17. // Variable to retrieve the return of this function
  18. var respLongList *LongList
  19. var errorsList *ServiceError
  20. var err error
  21. // Start the consumer
  22. respLongList, errorsList, err = archiveService.Delete(consumerURL, providerURL, objectType, identifierList, *longL
  24. // Check errors
  25. if err != nil {
  26.     // Do Something
  27. } else if errorsList != nil {
  28.     // Do something else
  29. }