func TestDriverNames(t *testing.T) {
allDriverNames := []string{
strings.ToLower(mock.MockOSDriverName),
strings.ToLower(mock.MockVolDriverName),
strings.ToLower(mock.MockStorDriverName),
strings.ToLower(mock.BadMockOSDriverName),
strings.ToLower(mock.BadMockVolDriverName),
strings.ToLower(mock.BadMockStorDriverName),
"linux",
"docker",
"ec2",
"openstack",
"rackspace",
"scaleio",
"xtremio",
}
var regDriverNames []string
for dn := range core.DriverNames() {
regDriverNames = append(regDriverNames, strings.ToLower(dn))
}
for _, n := range allDriverNames {
if !util.StringInSlice(n, regDriverNames) {
t.Fail()
}
}
for _, n := range regDriverNames {
if !util.StringInSlice(n, allDriverNames) {
t.Fail()
}
}
}
func TestEnvVars(t *testing.T) {
c := New()
c.Viper.Set("awsSecretKey", "Hello, world.")
if !util.StringInSlice("AWS_SECRET_KEY=Hello, world.", c.EnvVars()) {
t.Fail()
}
if util.StringInSlice("AWS_SECRET_KEY=Hello, world.", New().EnvVars()) {
t.Fail()
}
}
func GetDrivers(osDrivers string) (map[string]Driver, error) {
var err error
var osDriversArr []string
if osDrivers != "" {
osDriversArr = strings.Split(osDrivers, ",")
}
if debug == "TRUE" {
fmt.Println(driverInitFuncs)
}
for name, initFunc := range driverInitFuncs {
if len(osDriversArr) > 0 && !util.StringInSlice(name, osDriversArr) {
continue
}
drivers[name], err = initFunc()
if err != nil {
if debug == "TRUE" {
fmt.Println(fmt.Sprintf("Info (%s): %s", name, err))
}
delete(drivers, name)
}
}
return drivers, nil
}
func getDrivers(conf *config.Config) (map[string]Driver, error) {
driverNames := conf.OsDrivers
log.WithFields(log.Fields{
"driverInitFuncs": driverInitFuncs,
"driverNames": driverNames}).Debug("getting driver instances")
drivers := map[string]Driver{}
for name, initFunc := range driverInitFuncs {
if len(driverNames) > 0 && !util.StringInSlice(name, driverNames) {
continue
}
var initErr error
drivers[name], initErr = initFunc(conf)
if initErr != nil {
log.WithFields(log.Fields{
"driverName": name,
"error": initErr}).Debug("error initializing driver")
delete(drivers, name)
continue
}
log.WithField("driverName", name).Debug("initialized driver")
}
return drivers, nil
}
func TestRexRayDriverNames(t *testing.T) {
var err error
var r *core.RexRay
if r, err = getRexRay(); err != nil {
panic(err)
}
allDriverNames := []string{
strings.ToLower(mock.MockOSDriverName),
strings.ToLower(mock.MockVolDriverName),
strings.ToLower(mock.MockStorDriverName),
strings.ToLower(mock.BadMockOSDriverName),
strings.ToLower(mock.BadMockVolDriverName),
strings.ToLower(mock.BadMockStorDriverName),
"linux",
"docker",
"ec2",
"openstack",
"rackspace",
"scaleio",
"xtremio",
}
var regDriverNames []string
for dn := range r.DriverNames() {
regDriverNames = append(regDriverNames, strings.ToLower(dn))
}
for _, n := range allDriverNames {
if !util.StringInSlice(n, regDriverNames) {
t.Fail()
}
}
for _, n := range regDriverNames {
if !util.StringInSlice(n, allDriverNames) {
t.Fail()
}
}
}
func GetDrivers(daemonDrivers string) (map[string]Driver, error) {
var err error
var daemonDriversArr []string
if daemonDrivers != "" {
daemonDriversArr = strings.Split(daemonDrivers, ",")
}
if debug == "TRUE" {
fmt.Println(driverInitFuncs)
}
driverPriority := []string{
"dockervolumedriver",
"dockerremotevolumedriver",
}
for _, name := range driverPriority {
if len(daemonDriversArr) > 0 && !util.StringInSlice(name, daemonDriversArr) {
continue
}
var initFunc InitFunc
var ok bool
if initFunc, ok = driverInitFuncs[name]; !ok {
continue
}
drivers[name], err = initFunc()
if err != nil {
if debug == "TRUE" {
fmt.Println(fmt.Sprintf("Info (%s): %s", name, err))
}
delete(drivers, name)
}
return drivers, nil
}
return nil, errors.New("No daemon driver loaded")
}
// InitDrivers initializes the drivers for the REX-Ray platform.
func (r *RexRay) InitDrivers() error {
od := map[string]OSDriver{}
vd := map[string]VolumeDriver{}
sd := map[string]StorageDriver{}
for n, d := range r.drivers {
switch td := d.(type) {
case OSDriver:
if util.StringInSlice(n, r.Config.OSDrivers) {
if err := d.Init(r); err != nil {
log.WithFields(log.Fields{
"driverName": n,
"error": err}).Debug("error initializing driver")
continue
}
od[n] = td
}
case VolumeDriver:
if util.StringInSlice(n, r.Config.VolumeDrivers) {
if err := d.Init(r); err != nil {
log.WithFields(log.Fields{
"driverName": n,
"error": err}).Debug("error initializing driver")
continue
}
vd[n] = td
}
case StorageDriver:
if util.StringInSlice(n, r.Config.StorageDrivers) {
if err := d.Init(r); err != nil {
log.WithFields(log.Fields{
"driverName": n,
"error": err}).Debug("error initializing driver")
continue
}
sd[n] = td
}
}
}
r.OS = &odm{
rexray: r,
drivers: od,
}
r.Volume = &vdm{
rexray: r,
drivers: vd,
}
r.Storage = &sdm{
rexray: r,
drivers: sd,
}
if err := r.OS.Init(r); err != nil {
return err
}
if err := r.Volume.Init(r); err != nil {
return err
}
if err := r.Storage.Init(r); err != nil {
return err
}
return nil
}
// InitDrivers initializes the drivers for the REX-Ray platform.
func (r *RexRay) InitDrivers() error {
od := map[string]OSDriver{}
vd := map[string]VolumeDriver{}
sd := map[string]StorageDriver{}
log.Info(r.Config.Get("osDrivers"))
log.Info(r.Config.Get("volumeDrivers"))
log.Info(r.Config.Get("storageDrivers"))
osDrivers := r.Config.GetStringSlice("osDrivers")
volDrivers := r.Config.GetStringSlice("volumeDrivers")
storDrivers := r.Config.GetStringSlice("storageDrivers")
log.WithFields(log.Fields{
"osDrivers": osDrivers,
"volumeDrivers": volDrivers,
"storageDrivers": storDrivers,
}).Debug("core get drivers")
for n, d := range r.drivers {
switch td := d.(type) {
case OSDriver:
if util.StringInSlice(n, osDrivers) {
if err := d.Init(r); err != nil {
log.WithFields(log.Fields{
"driverName": n,
"error": err}).Debug("error initializing driver")
continue
}
od[n] = td
}
case VolumeDriver:
if util.StringInSlice(n, volDrivers) {
if err := d.Init(r); err != nil {
log.WithFields(log.Fields{
"driverName": n,
"error": err}).Debug("error initializing driver")
continue
}
vd[n] = td
}
case StorageDriver:
if util.StringInSlice(n, storDrivers) {
if err := d.Init(r); err != nil {
log.WithFields(log.Fields{
"driverName": n,
"error": err}).Debug("error initializing driver")
continue
}
sd[n] = td
}
}
}
r.OS = &odm{
rexray: r,
drivers: od,
}
r.Volume = &vdm{
rexray: r,
drivers: vd,
}
r.Storage = &sdm{
rexray: r,
drivers: sd,
}
if err := r.OS.Init(r); err != nil {
return err
}
if err := r.Volume.Init(r); err != nil {
return err
}
if err := r.Storage.Init(r); err != nil {
return err
}
return nil
}
func assertEnvVar(s string, evs []string, t *testing.T) {
if !util.StringInSlice(s, evs) {
t.Fatal(s)
}
}
