astelm/minio
1
0
Fork 0
mirror of https://github.com/pgsty/minio.git synced 2026-07-22 05:30:24 +03:00
Code Issues Packages Projects Releases Wiki Activity

Remove scsi non portable code, instead "donut make" implements functionality to instantiate a donut

Browse Source
This commit is contained in:
Harshavardhana
2015-07-15 11:55:49 -07:00
parent 49c705da99
commit 4498662c16
20 changed files with 40 additions and 563 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/utils/scsi/constants.go
-66
View File
@@ -1,66 +0,0 @@
// +build linux,amd64
/*
* Mini Object Storage, (C) 2014 Minio, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package scsi
// System sysfs constants
const (
// From 2.6.x kernel onwards, no need to support procfs
sysFSROOT = "/sys"
sysFSDEVICES = "/sys/bus/scsi/devices"
sysFSBLOCK = "/block"
sysFSCLASSSCSIDEVICES = "/sys/class/scsi_device"
udev = "/dev"
devDISKBYID = "/dev/disk/by-id"
)
// ScsiDEVICETYPES list of various scsi devices
var ScsiDEVICETYPES = []string{
"disk",
"tape",
"printer",
"process",
"worm",
"cd/dvd",
"scanner",
"optical",
"mediumx",
"comms",
"(0xa)",
"(0xb)",
"storage",
"enclosu",
"sim disk",
"optical rd",
"bridge",
"osd",
"adi",
"sec man",
"zbc",
"(0x15)",
"(0x16)",
"(0x17)",
"(0x18)",
"(0x19)",
"(0x1a)",
"(0x1b)",
"(0x1c)",
"(0x1e)",
"wlun",
"no dev",
}
pkg/utils/scsi/mountinfo.go
-112
View File
@@ -1,112 +0,0 @@
// +build linux
/*
* Mini Object Storage, (C) 2014 Minio, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package scsi
import (
"bufio"
"errors"
"io/ioutil"
"os"
"path/filepath"
"strconv"
"strings"
"syscall"
"github.com/minio/minio/pkg/iodine"
)
var supportedFSType = map[string]bool{
"ext4": true,
"xfs": true,
"ext3": true,
"btrfs": true,
"tmpfs": true,
"nfs": true,
}
func isSupportedType(t string) bool {
_, ok := supportedFSType[t]
return ok
}
// GetMountInfo - get mount info map
func GetMountInfo() (map[string]Mountinfo, error) {
f, err := os.Open("/etc/mtab")
if err != nil {
return nil, iodine.New(err, nil)
}
mntEnt := make(map[string]Mountinfo)
scanner := bufio.NewScanner(f)
for scanner.Scan() {
mtabEnt := strings.Split(scanner.Text(), " ")
mntInfo := Mountinfo{}
if len(mtabEnt) == 6 {
var err error
if !isSupportedType(mtabEnt[2]) {
continue
}
mntInfo.FSName, err = filepath.EvalSymlinks(mtabEnt[0])
if err != nil {
continue
}
mntInfo.Dir = mtabEnt[1]
mntInfo.Type = mtabEnt[2]
mntInfo.Opts = mtabEnt[3]
mntInfo.Freq, err = strconv.Atoi(mtabEnt[4])
if err != nil {
continue
}
mntInfo.Passno, err = strconv.Atoi(mtabEnt[5])
if err != nil {
continue
}
mntEnt[mntInfo.FSName] = mntInfo
}
}
return mntEnt, nil
}
// IsUsable provides a comprehensive way of knowing if the provided mountPath is mounted and writable
func IsUsable(mountPath string) (bool, error) {
mntpoint, err := os.Stat(mountPath)
if err != nil {
return false, iodine.New(err, nil)
}
parent, err := os.Stat(filepath.Join(mountPath, ".."))
if err != nil {
return false, iodine.New(err, nil)
}
mntpointSt := mntpoint.Sys().(*syscall.Stat_t)
parentSt := parent.Sys().(*syscall.Stat_t)
if mntpointSt.Dev == parentSt.Dev {
return false, iodine.New(errors.New("not mounted"), nil)
}
testFile, err := ioutil.TempFile(mountPath, "writetest-")
if err != nil {
return false, iodine.New(err, nil)
}
testFileName := testFile.Name()
// close the file, to avoid leaky fd's
testFile.Close()
if err := os.Remove(testFileName); err != nil {
return false, iodine.New(err, nil)
}
return true, nil
}
pkg/utils/scsi/mountinfo_darwin.go
-23
View File
@@ -1,23 +0,0 @@
/*
* Mini Object Storage, (C) 2014 Minio, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package scsi
// GetMountInfo - get mount info map
func GetMountInfo() (map[string]Mountinfo, error) {
// Stub implementation; returns an empty map
return make(map[string]Mountinfo), nil
}
pkg/utils/scsi/scsi-common.go
-62
View File
@@ -1,62 +0,0 @@
/*
* Mini Object Storage, (C) 2014 Minio, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package scsi
import (
"io/ioutil"
"os"
"path"
"strings"
)
// Attributes Scsi device attributes
type Attributes map[string]string
// Disks is a list of scsis disks and attributes
type Disks map[string]Attributes
// Mountinfo container to capture /etc/mtab mount structure
type Mountinfo struct {
FSName string /* name of mounted filesystem */
Dir string /* filesystem path prefix */
Type string /* mount type (see mntent.h) */
Opts string /* mount options (see mntent.h) */
Freq int /* dump frequency in days */
Passno int /* pass number on parallel fsck */
}
func getattrs(scsiAttrPath string, scsiAttrList []string) map[string]string {
attrMap := make(map[string]string)
for _, attr := range scsiAttrList {
value, _ := ioutil.ReadFile(path.Join(scsiAttrPath, attr))
attrMap[attr] = strings.Trim(string(value[:]), "\n") // remove odd newlines
}
return attrMap
}
func filterdisks(files []os.FileInfo) (scsidisks []string) {
for _, fi := range files {
if strings.Contains(fi.Name(), "host") {
continue
}
if strings.Contains(fi.Name(), "target") {
continue
}
scsidisks = append(scsidisks, fi.Name())
}
return scsidisks
}
pkg/utils/scsi/scsi.go
-96
View File
@@ -1,96 +0,0 @@
// +build linux,amd64
/*
* Minimalist Object Storage, (C) 2015 Minio, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package scsi
import (
"errors"
"io/ioutil"
"path/filepath"
"github.com/minio/minio/pkg/iodine"
)
// NOTE : supporting virtio based scsi devices is out of scope for this implementation
// Get get disk scsi params
func (d Disks) Get(disk string) Attributes {
return d[disk]
}
// Len return len of total disks
func (d Disks) Len() int {
return len(d)
}
// GetDisks - get system devices list
func GetDisks() (Disks, error) {
var scsidevices []string
var scsiAttrList []string
d := Disks{}
sysFiles, err := ioutil.ReadDir(sysFSDEVICES)
if err != nil {
// may be an amazon instance, ignore this
return Disks{}, nil
}
scsidevices = filterdisks(sysFiles)
if len(scsidevices) == 0 {
// may be a docker instance, ignore this
return Disks{}, nil
}
for _, s := range scsidevices {
scsiAttrPath := filepath.Join(sysFSDEVICES, s)
scsiAttrs, err := ioutil.ReadDir(scsiAttrPath)
if err != nil {
return Disks{}, iodine.New(err, nil)
}
scsiBlockPath := filepath.Join(sysFSDEVICES, s, sysFSBLOCK)
scsidevList, err := ioutil.ReadDir(scsiBlockPath)
if err != nil {
return Disks{}, iodine.New(err, nil)
}
if len(scsidevList) > 1 {
return Disks{}, iodine.New(errors.New("Scsi address points to multiple block devices"), nil)
}
device := filepath.Join(udev, scsidevList[0].Name())
for _, sa := range scsiAttrs {
// Skip directories
if sa.IsDir() {
continue
}
// Skip symlinks
if !sa.Mode().IsRegular() {
continue
}
// Skip, not readable, write-only
if sa.Mode().Perm() == 128 {
continue
}
scsiAttrList = append(scsiAttrList, sa.Name())
}
if len(scsiAttrList) == 0 {
return Disks{}, iodine.New(errors.New("No scsi attributes found"), nil)
}
d[device] = getattrs(scsiAttrPath, scsiAttrList)
}
return d, nil
}
pkg/utils/scsi/scsi_darwin.go
-23
View File
@@ -1,23 +0,0 @@
/*
* Minimalist Object Storage, (C) 2015 Minio, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package scsi
// GetDisks - get system devices list
func GetDisks() (Disks, error) {
// Stub implementation; returns empty disk information
return Disks{}, nil
}
pkg/utils/scsi/scsi_test.go
-39
View File
@@ -1,39 +0,0 @@
/*
* Minimalist Object Storage, (C) 2015 Minio, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package scsi
import (
"testing"
. "github.com/minio/check"
)
type MySuite struct{}
var _ = Suite(&MySuite{})
func Test(t *testing.T) { TestingT(t) }
func (s *MySuite) TestSCSI(c *C) {
_, err := GetDisks()
c.Assert(err, IsNil)
}
func (s *MySuite) TestMountInfo(c *C) {
_, err := GetMountInfo()
c.Assert(err, IsNil)
}