mongodb.go 17 KiB
Newer Older
// Deprecated: As of corepkgv2 tag 1.2.15 onwards no longer maintained,simply use coremongo and in future it will be removed.
Roshan Patil's avatar
Roshan Patil committed
package mongodb

import (
	"strconv"
	"strings"
Roshan Patil's avatar
Roshan Patil committed
	"sync"
Roshan Patil's avatar
Roshan Patil committed
	"time"
Roshan Patil's avatar
Roshan Patil committed

Roshan Patil's avatar
Roshan Patil committed
	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/statemdl"

	"gopkg.in/mgo.v2/bson"

Roshan Patil's avatar
Roshan Patil committed
	"github.com/tidwall/gjson"

	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/errormdl"
	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/loggermdl"

	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/configmdl"
Roshan Patil's avatar
Roshan Patil committed

	mgo "gopkg.in/mgo.v2"
)

Roshan Patil's avatar
Roshan Patil committed
// MongoHost -MongoHost
type MongoHost struct {
Roshan Patil's avatar
Roshan Patil committed
	HostName        string        `json:"hostName"`
	Server          string        `json:"server"`
	Port            int           `json:"port"`
Roshan Patil's avatar
Roshan Patil committed
	Username        string        `json:"username"`
	Password        string        `json:"password"`
	Database        string        `json:"database"`
	IsDefault       bool          `json:"isDefault"`
	MaxIdleConns    int           `json:"maxIdleConns" `
	MaxOpenConns    int           `json:"maxOpenConns"`
	ConnMaxLifetime time.Duration `json:"connMaxLifetime" `
	IsDisabled      bool          `json:"isDisabled" `
Roshan Patil's avatar
Roshan Patil committed
// TomlConfig - TomlConfig
type TomlConfig struct {
	MongoHosts map[string]MongoHost
}

var instances map[string]*mgo.Session
Roshan Patil's avatar
Roshan Patil committed
var mutex sync.Mutex
Roshan Patil's avatar
Roshan Patil committed
var once sync.Once
Roshan Patil's avatar
Roshan Patil committed
var config TomlConfig
Roshan Patil's avatar
Roshan Patil committed
var defaultHost string
Roshan Patil's avatar
Roshan Patil committed

Roshan Patil's avatar
Roshan Patil committed
// func init() {
// 	instances = make(map[string]*mgo.Session)
// }

// Init initializes Mongo Connections for give toml file
Roshan Patil's avatar
Roshan Patil committed
func Init(tomlFilepath, defaultHostName string) error {
	var sessionError error
Roshan Patil's avatar
Roshan Patil committed
	once.Do(func() {
Roshan Patil's avatar
Roshan Patil committed
		defer mutex.Unlock()
		mutex.Lock()
		instances = make(map[string]*mgo.Session)
		_, err := configmdl.InitConfig(tomlFilepath, &config)
		if errormdl.CheckErr(err) != nil {
			loggermdl.LogError(err)
Roshan Patil's avatar
Roshan Patil committed
			sessionError = err
			return
		}
		for hostName, hostDetails := range config.MongoHosts {
			session, err := mgo.DialWithInfo(&mgo.DialInfo{
				Addrs:    []string{bindMongoServerWithPort(hostDetails.Server, hostDetails.Port)},
				Username: hostDetails.Username,
Roshan Patil's avatar
Roshan Patil committed
				Timeout:  time.Second * 3,
				Password: hostDetails.Password,
				Database: hostDetails.Database,
			})
			if err != nil {
				sessionError = err
				loggermdl.LogError(sessionError)
				return
			}
			instances[hostName] = session
Roshan Patil's avatar
Roshan Patil committed
		}
Roshan Patil's avatar
Roshan Patil committed
		defaultHost = defaultHostName
Roshan Patil's avatar
Roshan Patil committed
// InitUsingJSON initializes Mongo Connections for give JSON data
Roshan Patil's avatar
Roshan Patil committed
func InitUsingJSON(configs []MongoHost) error {
Roshan Patil's avatar
Roshan Patil committed
	var sessionError error
	once.Do(func() {
Roshan Patil's avatar
Roshan Patil committed
		defer mutex.Unlock()
		mutex.Lock()
Roshan Patil's avatar
Roshan Patil committed
		config.MongoHosts = make(map[string]MongoHost)
Roshan Patil's avatar
Roshan Patil committed
		instances = make(map[string]*mgo.Session)
Roshan Patil's avatar
Roshan Patil committed
		for _, hostDetails := range configs {
			if hostDetails.IsDisabled {
				continue
			}
Roshan Patil's avatar
Roshan Patil committed
			session, err := mgo.DialWithInfo(&mgo.DialInfo{
				Addrs:    []string{bindMongoServerWithPort(hostDetails.Server, hostDetails.Port)},
Roshan Patil's avatar
Roshan Patil committed
				Username: hostDetails.Username,
				Password: hostDetails.Password,
				Timeout:  time.Second * 3,
Roshan Patil's avatar
Roshan Patil committed
				Database: hostDetails.Database,
			})

			if err != nil {
				sessionError = err
				loggermdl.LogError(sessionError)
				return
			}
Roshan Patil's avatar
Roshan Patil committed
			instances[hostDetails.HostName] = session
Roshan Patil's avatar
Roshan Patil committed
			if hostDetails.IsDefault {
Roshan Patil's avatar
Roshan Patil committed
				defaultHost = hostDetails.HostName
Roshan Patil's avatar
Roshan Patil committed
			}
Roshan Patil's avatar
Roshan Patil committed
			config.MongoHosts[hostDetails.HostName] = hostDetails
Roshan Patil's avatar
Roshan Patil committed
		}
	})
	return sessionError
}

Roshan Patil's avatar
Roshan Patil committed
// DeleteSession -DeleteSession
func DeleteSession(hostName string) error {
	defer mutex.Unlock()
	mutex.Lock()
	if _, ok := instances[hostName]; !ok {
		return errormdl.Wrap("NO_HOST_FOUND")
	}
	delete(instances, hostName)
	return nil
}

// InitNewSession - InitNewSession
func InitNewSession(hostDetails MongoHost) error {
	defer mutex.Unlock()
	mutex.Lock()
Roshan Patil's avatar
Roshan Patil committed
	if instances == nil {
		instances = make(map[string]*mgo.Session)
	}
Roshan Patil's avatar
Roshan Patil committed
	if _, ok := instances[hostDetails.HostName]; ok {
		return errormdl.Wrap("DUPLICATE_HOSTNAME")
	}
Roshan Patil's avatar
Roshan Patil committed
	session, err := mgo.DialWithInfo(&mgo.DialInfo{
		Addrs:    []string{bindMongoServerWithPort(hostDetails.Server, hostDetails.Port)},
Roshan Patil's avatar
Roshan Patil committed
		Username: hostDetails.Username,
Roshan Patil's avatar
Roshan Patil committed
		Timeout:  time.Second * 3,
Roshan Patil's avatar
Roshan Patil committed
		Password: hostDetails.Password,
		Database: hostDetails.Database,
	})

	if err != nil {
		loggermdl.LogError(err)
		return err
	}
	instances[hostDetails.HostName] = session
	return nil
}

// GetMongoConnection method
Roshan Patil's avatar
Roshan Patil committed
func GetMongoConnection(hostName string) (*mgo.Session, error) {
Roshan Patil's avatar
Roshan Patil committed
	defer mutex.Unlock()
	mutex.Lock()
	if instances == nil {
		return nil, errormdl.Wrap("MONGO_INIT_NOT_DONE")
	}
Roshan Patil's avatar
Roshan Patil committed
	if hostName == "" {
		if instance, ok := instances[defaultHost]; ok {
Roshan Patil's avatar
Roshan Patil committed
			statemdl.MongoHits()
			return instance.Copy(), nil
Roshan Patil's avatar
Roshan Patil committed
		}
	}
	if instance, ok := instances[hostName]; ok {
Roshan Patil's avatar
Roshan Patil committed
		statemdl.MongoHits()
		return instance.Copy(), nil
	}
	return nil, errormdl.Wrap("Session not found for instance: " + hostName)
}
// MongoDAO mongo DAO struct
type MongoDAO struct {
	hostName       string
	collectionName string
}
Roshan Patil's avatar
Roshan Patil committed
// GetMongoDAOWithHost return mongo DAO instance
func GetMongoDAOWithHost(host, collection string) *MongoDAO {
	return &MongoDAO{
		hostName:       host,
		collectionName: collection,
	}
}

Roshan Patil's avatar
Roshan Patil committed
// GetMongoDAO return mongo DAO instance
func GetMongoDAO(collection string) *MongoDAO {
	return &MongoDAO{
		collectionName: collection,
	}
}

// SaveData Save data in mongo db
func (mg *MongoDAO) SaveData(data interface{}) error {
Roshan Patil's avatar
Roshan Patil committed
	session, sessionError := GetMongoConnection(mg.hostName)
	if errormdl.CheckErr(sessionError) != nil {
		return errormdl.CheckErr(sessionError)
	}
	defer session.Close()
	if mg.hostName == "" {
		mg.hostName = defaultHost
	}
	db, ok := config.MongoHosts[mg.hostName]
	if errormdl.CheckBool(!ok) {
		return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
	}
	collection := session.DB(db.Database).C(mg.collectionName)
	insertError := collection.Insert(data)
	if errormdl.CheckErr1(insertError) != nil {
		return errormdl.CheckErr1(insertError)
	}
	return nil
}

// UpdateAll update all
func (mg *MongoDAO) UpdateAll(selector map[string]interface{}, data interface{}) error {
Roshan Patil's avatar
Roshan Patil committed
	session, sessionError := GetMongoConnection(mg.hostName)
	if errormdl.CheckErr(sessionError) != nil {
		return errormdl.CheckErr(sessionError)
	}
	defer session.Close()
	if mg.hostName == "" {
		mg.hostName = defaultHost
	}
	db, ok := config.MongoHosts[mg.hostName]
	if !ok {
		return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
	}
	collection := session.DB(db.Database).C(mg.collectionName)
	_, updateError := collection.UpdateAll(selector, bson.M{"$set": data})
	if errormdl.CheckErr1(updateError) != nil {
		return errormdl.CheckErr1(updateError)
	}
	return nil
}

// Update will update single entry
func (mg *MongoDAO) Update(selector map[string]interface{}, data interface{}) error {
Roshan Patil's avatar
Roshan Patil committed
	session, sessionError := GetMongoConnection(mg.hostName)
	if errormdl.CheckErr(sessionError) != nil {
		return errormdl.CheckErr(sessionError)
	}
	defer session.Close()
	if mg.hostName == "" {
		mg.hostName = defaultHost
	}
	db, ok := config.MongoHosts[mg.hostName]
	if !ok {
		return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
	}
	collection := session.DB(db.Database).C(mg.collectionName)
	updateError := collection.Update(selector, bson.M{"$set": data})
	if errormdl.CheckErr1(updateError) != nil {
		return errormdl.CheckErr1(updateError)
	}
	return nil
}

// GetData will return query for selector
Roshan Patil's avatar
Roshan Patil committed
func (mg *MongoDAO) GetData(selector map[string]interface{}) (*gjson.Result, error) {
Roshan Patil's avatar
Roshan Patil committed
	session, sessionError := GetMongoConnection(mg.hostName)
	if errormdl.CheckErr(sessionError) != nil {
		return nil, errormdl.CheckErr(sessionError)
	}
	defer session.Close()
	if mg.hostName == "" {
		mg.hostName = defaultHost
	}
	db, ok := config.MongoHosts[mg.hostName]
	if !ok {
		return nil, errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
	}
	collection := session.DB(db.Database).C(mg.collectionName)
Roshan Patil's avatar
Roshan Patil committed
	var result []interface{}
	collection.Find(selector).All(&result)
Roshan Patil's avatar
Roshan Patil committed
	ba, marshalError := json.Marshal(result)
	if errormdl.CheckErr2(marshalError) != nil {
		return nil, errormdl.CheckErr2(marshalError)
	}
Roshan Patil's avatar
Roshan Patil committed
	rs := gjson.ParseBytes(ba)
	return &rs, nil
}

// DeleteData will delete data given for selector
func (mg *MongoDAO) DeleteData(selector map[string]interface{}) error {
Roshan Patil's avatar
Roshan Patil committed
	session, sessionError := GetMongoConnection(mg.hostName)
	if errormdl.CheckErr(sessionError) != nil {
		return errormdl.CheckErr(sessionError)
	}
	defer session.Close()
	if mg.hostName == "" {
		mg.hostName = defaultHost
	}
	db, ok := config.MongoHosts[mg.hostName]
	if !ok {
		return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
	}
	collection := session.DB(db.Database).C(mg.collectionName)
	deleteError := collection.Remove(selector)
	if errormdl.CheckErr1(deleteError) != nil {
		return errormdl.CheckErr1(deleteError)
	}
	return deleteError
}

// DeleteAll will delete all the matching data given for selector
func (mg *MongoDAO) DeleteAll(selector map[string]interface{}) error {
Roshan Patil's avatar
Roshan Patil committed
	session, sessionError := GetMongoConnection(mg.hostName)
	if errormdl.CheckErr(sessionError) != nil {
		return errormdl.CheckErr(sessionError)
	}
	defer session.Close()
	if mg.hostName == "" {
		mg.hostName = defaultHost
	}
	db, ok := config.MongoHosts[mg.hostName]
	if !ok {
		return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
	}
	collection := session.DB(db.Database).C(mg.collectionName)
	_, deleteError := collection.RemoveAll(selector)
	if errormdl.CheckErr1(deleteError) != nil {
		return errormdl.CheckErr1(deleteError)
	}
	return deleteError
Roshan Patil's avatar
Roshan Patil committed
}

// GetProjectedData will return query for selector and projector
func (mg *MongoDAO) GetProjectedData(selector map[string]interface{}, projector map[string]interface{}) (*gjson.Result, error) {
Roshan Patil's avatar
Roshan Patil committed
	session, sessionError := GetMongoConnection(mg.hostName)
	if errormdl.CheckErr(sessionError) != nil {
		return nil, errormdl.CheckErr(sessionError)
	}
	defer session.Close()
	if mg.hostName == "" {
		mg.hostName = defaultHost
	}
	db, ok := config.MongoHosts[mg.hostName]
	if !ok {
		return nil, errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
	}
	collection := session.DB(db.Database).C(mg.collectionName)
	var result []interface{}
	collection.Find(selector).Select(projector).All(&result)
	ba, marshalError := json.Marshal(result)
	if errormdl.CheckErr2(marshalError) != nil {
		return nil, errormdl.CheckErr2(marshalError)
	}
	rs := gjson.ParseBytes(ba)
	return &rs, nil
}

// GetAggregateData - return result using aggregation query
func (mg *MongoDAO) GetAggregateData(selector interface{}) (*gjson.Result, error) {
Roshan Patil's avatar
Roshan Patil committed
	session, sessionError := GetMongoConnection(mg.hostName)
	if errormdl.CheckErr(sessionError) != nil {
		return nil, errormdl.CheckErr(sessionError)
	}
	defer session.Close()
	if mg.hostName == "" {
		mg.hostName = defaultHost
	}
	db, ok := config.MongoHosts[mg.hostName]
	if !ok {
		return nil, errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
	}
	collection := session.DB(db.Database).C(mg.collectionName)
	var result []bson.M
	collection.Pipe(selector).All(&result)
	ba, marshalError := json.Marshal(result)
	if errormdl.CheckErr2(marshalError) != nil {
		return nil, errormdl.CheckErr2(marshalError)
	}
	rs := gjson.ParseBytes(ba)
	return &rs, nil
}
Roshan Patil's avatar
Roshan Patil committed

// Upsert will update single entry
func (mg *MongoDAO) Upsert(selector map[string]interface{}, data interface{}) error {
Roshan Patil's avatar
Roshan Patil committed
	session, sessionError := GetMongoConnection(mg.hostName)
Roshan Patil's avatar
Roshan Patil committed
	if errormdl.CheckErr(sessionError) != nil {
		return errormdl.CheckErr(sessionError)
	}
	defer session.Close()
Roshan Patil's avatar
Roshan Patil committed
	if mg.hostName == "" {
		mg.hostName = defaultHost
	}
	db, ok := config.MongoHosts[mg.hostName]
	if !ok {
		return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
	}
	collection := session.DB(db.Database).C(mg.collectionName)
	_, updateError := collection.Upsert(selector, bson.M{"$set": data})
	if errormdl.CheckErr1(updateError) != nil {
		return errormdl.CheckErr1(updateError)
	}
	return nil
}

// PushData - append in array
func (mg *MongoDAO) PushData(selector map[string]interface{}, data interface{}) error {
Roshan Patil's avatar
Roshan Patil committed
	session, sessionError := GetMongoConnection(mg.hostName)
	if errormdl.CheckErr(sessionError) != nil {
		return errormdl.CheckErr(sessionError)
	}
	defer session.Close()
	if mg.hostName == "" {
		mg.hostName = defaultHost
	}
	db, ok := config.MongoHosts[mg.hostName]
	if !ok {
		return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
	}
	collection := session.DB(db.Database).C(mg.collectionName)
	_, updateError := collection.UpdateAll(selector, bson.M{"$push": data})
Roshan Patil's avatar
Roshan Patil committed
	if errormdl.CheckErr1(updateError) != nil {
		return errormdl.CheckErr1(updateError)
	}
	return nil
}

// CustomUpdate - CustomUpdate
func (mg *MongoDAO) CustomUpdate(selector map[string]interface{}, data interface{}) error {
Roshan Patil's avatar
Roshan Patil committed
	session, sessionError := GetMongoConnection(mg.hostName)
	if errormdl.CheckErr(sessionError) != nil {
		return errormdl.CheckErr(sessionError)
	}
	defer session.Close()
	if mg.hostName == "" {
		mg.hostName = defaultHost
	}
	db, ok := config.MongoHosts[mg.hostName]
	if !ok {
		return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
	}
	collection := session.DB(db.Database).C(mg.collectionName)
	_, updateError := collection.UpdateAll(selector, data)
	if errormdl.CheckErr1(updateError) != nil {
		return errormdl.CheckErr1(updateError)
	}
	return nil
}
Roshan Patil's avatar
Roshan Patil committed

// CustomUpdateOne - CustomUpdateOne
func (mg *MongoDAO) CustomUpdateOne(selector map[string]interface{}, data interface{}) error {
Roshan Patil's avatar
Roshan Patil committed
	session, sessionError := GetMongoConnection(mg.hostName)
Roshan Patil's avatar
Roshan Patil committed
	if errormdl.CheckErr(sessionError) != nil {
		return errormdl.CheckErr(sessionError)
	}
	defer session.Close()
Roshan Patil's avatar
Roshan Patil committed
	if mg.hostName == "" {
		mg.hostName = defaultHost
	}
	db, ok := config.MongoHosts[mg.hostName]
	if !ok {
		return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
	}
	collection := session.DB(db.Database).C(mg.collectionName)
	updateError := collection.Update(selector, data)
	if errormdl.CheckErr1(updateError) != nil {
		return errormdl.CheckErr1(updateError)
	}
	return nil
}

/************************* BULK Functionalities ******************************/

// BulkSaveData ata Save data in mongo db in bulk
Roshan Patil's avatar
Roshan Patil committed
func (mg *MongoDAO) BulkSaveData(data []interface{}) error {
Roshan Patil's avatar
Roshan Patil committed
	session, sessionError := GetMongoConnection(mg.hostName)
Roshan Patil's avatar
Roshan Patil committed
	if errormdl.CheckErr(sessionError) != nil {
		return errormdl.CheckErr(sessionError)
	}
	defer session.Close()
Roshan Patil's avatar
Roshan Patil committed
	if mg.hostName == "" {
		mg.hostName = defaultHost
	}
	db, ok := config.MongoHosts[mg.hostName]
	if errormdl.CheckBool(!ok) {
		return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
	}
	collection := session.DB(db.Database).C(mg.collectionName)
Roshan Patil's avatar
Roshan Patil committed
	b := collection.Bulk()
	b.Insert(data...)
	_, insertError := b.Run()
Roshan Patil's avatar
Roshan Patil committed
	if errormdl.CheckErr1(insertError) != nil {
		loggermdl.LogError(insertError)
		return errormdl.CheckErr1(insertError)
	}
	return nil
}

// BulkUpdateData  update data in mongo db in bulk
func (mg *MongoDAO) BulkUpdateData(data []interface{}) error {
	session, sessionError := GetMongoConnection(mg.hostName)
	if errormdl.CheckErr(sessionError) != nil {
		return errormdl.CheckErr(sessionError)
	}
	defer session.Close()
Roshan Patil's avatar
Roshan Patil committed
	if mg.hostName == "" {
		mg.hostName = defaultHost
	}
	db, ok := config.MongoHosts[mg.hostName]
	if errormdl.CheckBool(!ok) {
		return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
	}
	collection := session.DB(db.Database).C(mg.collectionName)
	b := collection.Bulk()
Roshan Patil's avatar
Roshan Patil committed
	b.UpdateAll(data...)
Roshan Patil's avatar
Roshan Patil committed
	_, insertError := b.Run()
	if errormdl.CheckErr1(insertError) != nil {
		return errormdl.CheckErr1(insertError)
	}
	return nil
}

// BulkDeleteData  delete data in mongo db in bulk
func (mg *MongoDAO) BulkDeleteData(data []interface{}) error {
	session, sessionError := GetMongoConnection(mg.hostName)
	if errormdl.CheckErr(sessionError) != nil {
		return errormdl.CheckErr(sessionError)
	}
	defer session.Close()
Roshan Patil's avatar
Roshan Patil committed
	if mg.hostName == "" {
		mg.hostName = defaultHost
	}
	db, ok := config.MongoHosts[mg.hostName]
	if errormdl.CheckBool(!ok) {
		return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
	}
	collection := session.DB(db.Database).C(mg.collectionName)
	b := collection.Bulk()
Roshan Patil's avatar
Roshan Patil committed
	b.RemoveAll(data...)
Roshan Patil's avatar
Roshan Patil committed
	_, insertError := b.Run()
	if errormdl.CheckErr1(insertError) != nil {
		return errormdl.CheckErr1(insertError)
	}
	return nil
}

// BulkUpsertData  Upsert data in mongo db in bulk
func (mg *MongoDAO) BulkUpsertData(data []interface{}) error {
	session, sessionError := GetMongoConnection(mg.hostName)
	if errormdl.CheckErr(sessionError) != nil {
		return errormdl.CheckErr(sessionError)
	}
	defer session.Close()
Roshan Patil's avatar
Roshan Patil committed
	if mg.hostName == "" {
		mg.hostName = defaultHost
	}
	db, ok := config.MongoHosts[mg.hostName]
	if errormdl.CheckBool(!ok) {
		return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
	}
	collection := session.DB(db.Database).C(mg.collectionName)
	b := collection.Bulk()
	b.Upsert(data...)
	_, insertError := b.Run()
Roshan Patil's avatar
Roshan Patil committed
	if errormdl.CheckErr1(insertError) != nil {
		return errormdl.CheckErr1(insertError)
	}
	return nil
}
func bindMongoServerWithPort(server string, port int) string {
	// if port is empty then used default port 27017 & bind to server ip
	var serverURI string
	if port <= 0 || strings.TrimSpace(strconv.Itoa(port)) == "" {
		serverURI = server + ":27017"
	} else {
		serverURI = server + ":" + strconv.Itoa(port)