oyd
/
minio
6
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Remove linux specific code for now, bring them in later

Browse Source
master
Harshavardhana 10 years ago
parent 63d9689214
commit 9401262f75
9 changed files with 4 additions and 429 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 8
      Makefile
  2. 1
      pkg/os/scsi/.gitignore
  3. 63
      pkg/os/scsi/constants_linux.go
  4. 47
      pkg/os/scsi/errors.go
  5. 169
      pkg/os/scsi/scsi_linux.go
  6. 23
      pkg/os/scsi/scsi_test.go
  7. 48
      pkg/os/scsi/utils_linux.go
  8. 52
      pkg/os/sysctl/sysctl_linux.go
  9. 22
      pkg/os/sysctl/sysctl_test.go

8
Makefile
Unescape View File

@ -20,9 +20,9 @@ build-utils:
@godep go test -race -coverprofile=cover.out github.com/minio-io/minio/pkg/utils/crypto/sha512/
@godep go test -race -coverprofile=cover.out github.com/minio-io/minio/pkg/utils/checksum/crc32c
build-os:
@godep go test -race -coverprofile=cover.out github.com/minio-io/minio/pkg/os/scsi
@godep go test -race -coverprofile=cover.out github.com/minio-io/minio/pkg/os/sysctl
#build-os:
# @godep go test -race -coverprofile=cover.out github.com/minio-io/minio/pkg/os/scsi
# @godep go test -race -coverprofile=cover.out github.com/minio-io/minio/pkg/os/sysctl
build-storage:
@$(MAKE) $(MAKE_OPTIONS) -C pkg/storage/erasure/isal lib
@ -31,7 +31,7 @@ build-storage:
build-minioapi:
@godep go test -race -coverprofile=cover.out github.com/minio-io/minio/pkg/webapi/minioapi
cover: build-storage build-os build-utils build-minioapi
cover: build-storage build-utils build-minioapi
install: cover

1
pkg/os/scsi/.gitignore vendored
Unescape View File

@ -1 +0,0 @@
scsi

63
pkg/os/scsi/constants_linux.go
Unescape View File

@ -1,63 +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.
*/
// !build linux,amd64
package scsi
var (
// From 2.6.x kernel onwards, no need to support procfs
SYSFS_SCSI_DEVICES = "/sys/bus/scsi/devices/"
SYSFS_BLOCK = "/sys/block/"
SYSFS_CLASS_SCSI_DEVICES = "/sys/class/scsi_device/"
UDEV = "/dev/"
DEV_DISK_BYID_DIR = "/dev/disk/by-id"
)
var SCSI_DEVICE_TYPES = []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",
}

47
pkg/os/scsi/errors.go
Unescape View File

@ -1,47 +0,0 @@
/*
* Mini 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
type NoDiskAttributesFound struct{}
func (self NoDiskAttributesFound) Error() string {
return "No Disk Attributes Found"
}
type NoDiskQueueAttributesFound struct{}
func (self NoDiskQueueAttributesFound) Error() string {
return "No Disk Queue Attributes Found"
}
type NoScsiDevicesFoundOnSystem struct{}
func (self NoScsiDevicesFoundOnSystem) Error() string {
return "No scsi devices found on the system"
}
type ScsiAddressPointsToMultipleBlockDevices struct{}
func (self ScsiAddressPointsToMultipleBlockDevices) Error() string {
return "Scsi address points to multiple block devices"
}
type NoScsiAttributesFound struct{}
func (self NoScsiAttributesFound) Error() string {
return "No Scsi Attributes Found"
}

169
pkg/os/scsi/scsi_linux.go
Unescape View File

@ -1,169 +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.
*/
// !build linux,amd64
package scsi
import (
"io/ioutil"
"path"
)
// NOTE : supporting virtio based scsi devices
// is out of scope for this implementation
type Scsi struct {
Disk string
Scsiattrmap map[string][]byte
Diskattrmap map[string][]byte
}
type Devices struct {
List []Scsi
}
func (d *Devices) getInfo(disk string) (map[string][]byte, error) {
var diskAttrsList []string
var diskQueueAttrs []string
aggrAttrMap := make(map[string][]byte)
sysfs_block_dev := path.Join(SYSFS_BLOCK + disk)
sysfs_block_dev_queue := path.Join(sysfs_block_dev + "/queue")
scsiFiles, err := ioutil.ReadDir(sysfs_block_dev)
if err != nil {
return nil, err
}
scsiQueueFiles, err := ioutil.ReadDir(sysfs_block_dev_queue)
if err != nil {
return nil, err
}
for _, sf := range scsiFiles {
if sf.IsDir() {
continue
}
// Skip symlinks
if !sf.Mode().IsRegular() {
continue
}
// Skip, not readable, write-only
if sf.Mode().Perm() == 128 {
continue
}
diskAttrsList = append(diskAttrsList, sf.Name())
}
for _, sf := range scsiQueueFiles {
if sf.IsDir() {
continue
}
// Skip symlinks
if !sf.Mode().IsRegular() {
continue
}
// Skip, not readable, write-only
if sf.Mode().Perm() == 128 {
continue
}
diskQueueAttrs = append(diskQueueAttrs, sf.Name())
}
if len(diskAttrsList) == 0 {
return nil, NoDiskAttributesFound{}
}
if len(diskQueueAttrs) == 0 {
return nil, NoDiskQueueAttributesFound{}
}
diskAttrMap := getattrs(sysfs_block_dev, diskAttrsList)
diskQueueAttrMap := getattrs(sysfs_block_dev_queue, diskQueueAttrs)
for k, v := range diskAttrMap {
aggrAttrMap[k] = v
}
for k, v := range diskQueueAttrMap {
aggrAttrMap[k] = v
}
return aggrAttrMap, nil
}
func (d *Devices) Get() error {
var scsidevices []string
var scsiAttrList []string
sysFiles, err := ioutil.ReadDir(SYSFS_SCSI_DEVICES)
if err != nil {
return err
}
scsidevices = filterdevices(sysFiles)
if len(scsidevices) == 0 {
return NoScsiDevicesFoundOnSystem{}
}
for _, scsi := range scsidevices {
var _scsi Scsi
scsiAttrPath := path.Join(SYSFS_SCSI_DEVICES, scsi, "/")
scsiAttrs, err := ioutil.ReadDir(scsiAttrPath)
if err != nil {
return err
}
scsiBlockPath := path.Join(SYSFS_SCSI_DEVICES, scsi, "/block")
scsidevList, err := ioutil.ReadDir(scsiBlockPath)
if err != nil {
return err
}
if len(scsidevList) > 1 {
return ScsiAddressPointsToMultipleBlockDevices{}
}
_scsi.Disk = 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 NoScsiAttributesFound{}
}
attrMap := getattrs(scsiAttrPath, scsiAttrList)
_scsi.Scsiattrmap = attrMap
_scsi.Diskattrmap, err = d.getInfo(scsidevList[0].Name())
if err != nil {
return err
}
d.List = append(d.List, _scsi)
}
return nil
}

23
pkg/os/scsi/scsi_test.go
Unescape View File

@ -1,23 +0,0 @@
// !build linux,amd64
package scsi
import (
. "gopkg.in/check.v1"
"testing"
)
type MySuite struct{}
var _ = Suite(&MySuite{})
func Test(t *testing.T) { TestingT(t) }
func (s *MySuite) TestSCSI(c *C) {
var d Devices
err := d.Get()
c.Assert(err, IsNil)
c.Assert(len(d.List), Equals, 1)
c.Assert(len(d.List[0].Scsiattrmap), Not(Equals), 0)
c.Assert(len(d.List[0].Diskattrmap), Not(Equals), 0)
}

48
pkg/os/scsi/utils_linux.go
Unescape View File

@ -1,48 +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.
*/
// !build linux,amd64
package scsi
import (
"io/ioutil"
"os"
"path"
"strings"
)
func getattrs(scsiAttrPath string, scsiAttrList []string) map[string][]byte {
attrMap := make(map[string][]byte)
for _, attr := range scsiAttrList {
value, _ := ioutil.ReadFile(path.Join(scsiAttrPath, attr))
attrMap[attr] = value
}
return attrMap
}
func filterdevices(files []os.FileInfo) (scsidevices []string) {
for _, fi := range files {
if strings.Contains(fi.Name(), "host") {
continue
}
if strings.Contains(fi.Name(), "target") {
continue
}
scsidevices = append(scsidevices, fi.Name())
}
return scsidevices
}

52
pkg/os/sysctl/sysctl_linux.go
Unescape View File

@ -1,52 +0,0 @@
// !build linux,amd64
package sysctl
import (
"bufio"
"os/exec"
"strings"
"github.com/minio-io/minio/pkg/utils"
)
type Sysctl struct {
Sysattrmap map[string][]byte
}
func (s *Sysctl) Get() error {
attrMap := make(map[string][]byte)
// Get full system level list
sysctl_cmd := exec.Command("sysctl", "-a")
// Sort the output and throw away duplicate keys
sort_cmd := exec.Command("sort", "-u")
// Ignore permission denied errors from sysctl output
grep_cmd := exec.Command("grep", "-v", "permission")
output, err := utils.ExecPipe(sysctl_cmd, sort_cmd, grep_cmd)
if err != nil {
return err
}
scanner := bufio.NewScanner(output)
split := func(data []byte, atEOF bool) (advance int, token []byte, err error) {
advance, token, err = bufio.ScanLines(data, atEOF)
return
}
scanner.Split(split)
for scanner.Scan() {
split := strings.Split(scanner.Text(), "=")
if len(split) < 1 {
println("Invalid token skip..")
continue
}
k, v := strings.TrimSpace(split[0]), strings.TrimSpace(split[1])
attrMap[k] = []byte(v)
}
s.Sysattrmap = attrMap
return nil
}

22
pkg/os/sysctl/sysctl_test.go
Unescape View File

@ -1,22 +0,0 @@
// !build linux,amd64
package sysctl
import (
"testing"
. "gopkg.in/check.v1"
)
type MySuite struct{}
var _ = Suite(&MySuite{})
func Test(t *testing.T) { TestingT(t) }
func (s *MySuite) TestSysctl(c *C) {
sysctl := Sysctl{}
err := sysctl.Get()
c.Assert(err, IsNil)
c.Assert(sysctl.Sysattrmap, Not(Equals), 0)
}
Write Preview
Loading…
Cancel
Save