func domainsExpand(domainDAO dao.DomainDAO) {
newDomains := newDomains()
domainsResult := domainDAO.SaveMany(newDomains)
for _, domainResult := range domainsResult {
if domainResult.Error != nil {
utils.Fatalln("Error creating domains", domainResult.Error)
}
}
pagination := dao.DomainDAOPagination{}
domains, err := domainDAO.FindAll(&pagination, false, "")
if err != nil {
utils.Fatalln("Error retrieving domains", err)
}
for _, domain := range domains {
if len(domain.Owners) > 0 {
utils.Fatalln("Not compressing owners in results", nil)
}
for _, nameserver := range domain.Nameservers {
if len(nameserver.Host) > 0 ||
nameserver.IPv4 != nil ||
nameserver.IPv6 != nil ||
!nameserver.LastCheckAt.Equal(time.Time{}) ||
!nameserver.LastOKAt.Equal(time.Time{}) {
utils.Fatalln("Not compressing nameservers in results", nil)
}
}
for _, ds := range domain.DSSet {
if ds.Algorithm != 0 ||
len(ds.Digest) > 0 ||
ds.DigestType != 0 ||
ds.Keytag != 0 ||
!ds.ExpiresAt.Equal(time.Time{}) ||
!ds.LastCheckAt.Equal(time.Time{}) ||
!ds.LastOKAt.Equal(time.Time{}) {
utils.Fatalln("Not compressing ds set in results", nil)
}
}
}
domains, err = domainDAO.FindAll(&pagination, true, "")
if err != nil {
utils.Fatalln("Error retrieving domains", err)
}
for _, domain := range domains {
if len(domain.Owners) == 0 {
utils.Fatalln("Compressing owners in results when it shouldn't", nil)
}
for _, nameserver := range domain.Nameservers {
if len(nameserver.Host) == 0 ||
nameserver.IPv4 == nil ||
nameserver.IPv6 == nil ||
nameserver.LastCheckAt.Equal(time.Time{}) ||
nameserver.LastOKAt.Equal(time.Time{}) ||
nameserver.LastStatus != model.NameserverStatusOK {
utils.Fatalln("Compressing nameservers in results when it shouldn't", nil)
}
}
for _, ds := range domain.DSSet {
if ds.Algorithm == 0 ||
len(ds.Digest) == 0 ||
ds.DigestType == 0 ||
ds.Keytag == 0 ||
ds.ExpiresAt.Equal(time.Time{}) ||
ds.LastCheckAt.Equal(time.Time{}) ||
ds.LastOKAt.Equal(time.Time{}) ||
ds.LastStatus != model.DSStatusOK {
utils.Fatalln("Compressing ds set in results when it shouldn't", nil)
}
}
}
domainsResult = domainDAO.RemoveMany(newDomains)
for _, domainResult := range domainsResult {
if domainResult.Error != nil {
utils.Fatalln("Error removing domains", domainResult.Error)
}
}
}
func calculateDomainDAODurations(domainDAO dao.DomainDAO, numberOfItems int) (totalDuration, insertDuration,
queryDuration, removeDuration time.Duration) {
beginTimer := time.Now()
sectionTimer := beginTimer
// Build array to create many at once
var domains []*model.Domain
for i := 0; i < numberOfItems; i++ {
domain := model.Domain{
FQDN: fmt.Sprintf("test%d.com.br", i),
}
domains = append(domains, &domain)
}
errorInDomainsCreation := false
domainResults := domainDAO.SaveMany(domains)
// Check if there was any error while creating them
for _, domainResult := range domainResults {
if domainResult.Error != nil {
errorInDomainsCreation = true
utils.Errorln(fmt.Sprintf("Couldn't save domain %s in database during the performance test",
domainResult.Domain.FQDN), domainResult.Error)
}
}
if errorInDomainsCreation {
utils.Fatalln("Due to errors in domain creation, the performance test will be aborted", nil)
}
insertDuration = time.Since(sectionTimer)
sectionTimer = time.Now()
// Try to find domains from different parts of the whole range to check indexes
queryRanges := numberOfItems / 4
fqdn1 := fmt.Sprintf("test%d.com.br", queryRanges)
fqdn2 := fmt.Sprintf("test%d.com.br", queryRanges*2)
fqdn3 := fmt.Sprintf("test%d.com.br", queryRanges*3)
if _, err := domainDAO.FindByFQDN(fqdn1); err != nil {
utils.Fatalln(fmt.Sprintf("Couldn't find domain %s in database during "+
"the performance test", fqdn1), err)
}
if _, err := domainDAO.FindByFQDN(fqdn2); err != nil {
utils.Fatalln(fmt.Sprintf("Couldn't find domain %s in database during "+
"the performance test", fqdn2), err)
}
if _, err := domainDAO.FindByFQDN(fqdn3); err != nil {
utils.Fatalln(fmt.Sprintf("Couldn't find domain %s in database during "+
"the performance test", fqdn3), err)
}
queryDuration = time.Since(sectionTimer)
sectionTimer = time.Now()
errorInDomainsRemoval := false
domainResults = domainDAO.RemoveMany(domains)
// Check if there was any error while removing them
for _, domainResult := range domainResults {
if domainResult.Error != nil {
errorInDomainsRemoval = true
utils.Errorln(fmt.Sprintf("Error while trying to remove a domain %s during the performance test",
domainResult.Domain.FQDN), domainResult.Error)
}
}
if errorInDomainsRemoval {
utils.Fatalln("Due to errors in domain removal, the performance test will be aborted", nil)
}
removeDuration = time.Since(sectionTimer)
totalDuration = time.Since(beginTimer)
return
}
// Test all phases from a domain lyfe cycle, but now working with a group of domains
func domainsLifeCycle(domainDAO dao.DomainDAO) {
domains := newDomains()
// Create domains
domainResults := domainDAO.SaveMany(domains)
for _, domainResult := range domainResults {
if domainResult.Error != nil {
utils.Fatalln(fmt.Sprintf("Couldn't save domain %s in database",
domainResult.Domain.FQDN), domainResult.Error)
}
}
for _, domain := range domains {
// Search and compare created domains
if domainRetrieved, err := domainDAO.FindByFQDN(domain.FQDN); err != nil {
utils.Fatalln(fmt.Sprintf("Couldn't find created domain %s in database", domain.FQDN), err)
} else if !utils.CompareDomain(*domain, domainRetrieved) {
utils.Fatalln(fmt.Sprintf("Domain %s created is being persisted wrongly", domain.FQDN), nil)
}
}
// Update domains
for _, domain := range domains {
domain.Owners = []model.Owner{}
}
domainResults = domainDAO.SaveMany(domains)
for _, domainResult := range domainResults {
if domainResult.Error != nil {
utils.Fatalln(fmt.Sprintf("Couldn't update domain %s in database",
domainResult.Domain.FQDN), domainResult.Error)
}
}
for _, domain := range domains {
// Search and compare updated domains
if domainRetrieved, err := domainDAO.FindByFQDN(domain.FQDN); err != nil {
utils.Fatalln(fmt.Sprintf("Couldn't find updated domain %s in database", domain.FQDN), err)
} else if !utils.CompareDomain(*domain, domainRetrieved) {
utils.Fatalln(fmt.Sprintf("Domain %s updated in being persisted wrongly", domain.FQDN), nil)
}
}
// Check if find all really return all domains
allDomainsChannel, err := domainDAO.FindAllAsync()
if err != nil {
utils.Fatalln("Error while retrieving all domains from database", err)
}
var allDomains []model.Domain
for {
domainRetrieved := <-allDomainsChannel
if domainRetrieved.Error != nil {
utils.Fatalln("Error while retrieving all domains from database", err)
} else if domainRetrieved.Domain == nil {
break
}
allDomains = append(allDomains, *domainRetrieved.Domain)
}
if len(allDomains) != len(domains) {
utils.Fatalln(fmt.Sprintf("FindAll method is not returning all domains we expected %d but got %d",
len(domains), len(allDomains)), nil)
}
// Detected a problem in FindAsync method on 2014-01-17 where we were returning the same
// object many times because we were reusing the same pointer. For that reason we are
// going to add a test to check if the items returned are the same set of the inserted
// ones
for _, domain := range domains {
found := false
for _, domainRetrieved := range allDomains {
if domainRetrieved.Id.Hex() == domain.Id.Hex() {
found = true
break
}
}
if !found {
utils.Fatalln("FindAll method is not returning all objects "+
"that were inserted, apparently there are duplicated objects in the result set", nil)
}
}
// Remove domains
domainResults = domainDAO.RemoveMany(domains)
for _, domainResult := range domainResults {
if domainResult.Error != nil {
utils.Fatalln(fmt.Sprintf("Error while trying to remove domain %s from database",
domainResult.Domain.FQDN), domainResult.Error)
}
}
for _, domain := range domains {
// Check removals
if _, err := domainDAO.FindByFQDN(domain.FQDN); err == nil {
utils.Fatalln(fmt.Sprintf("Domain %s was not removed from database", domain.FQDN), nil)
}
}
// Let's add and remove the domains again to test the remove all method
domainResults = domainDAO.SaveMany(domains)
for _, domainResult := range domainResults {
if domainResult.Error != nil {
utils.Fatalln(fmt.Sprintf("Couldn't save domain %s in database",
domainResult.Domain.FQDN), domainResult.Error)
}
}
if err := domainDAO.RemoveAll(); err != nil {
utils.Fatalln("Couldn't remove all domains", err)
}
allDomainsChannel, err = domainDAO.FindAllAsync()
if err != nil {
utils.Fatalln("Error while retrieving all domains from database", err)
}
allDomains = []model.Domain{}
for {
domainRetrieved := <-allDomainsChannel
if domainRetrieved.Error != nil {
utils.Fatalln("Error while retrieving all domains from database", err)
} else if domainRetrieved.Domain == nil {
break
}
allDomains = append(allDomains, *domainRetrieved.Domain)
}
if len(allDomains) > 0 {
utils.Fatalln("RemoveAll method is not removing the domains from the database", nil)
}
}