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

Remove custom Config, will use quick Config instead for user access keys

Browse Source
master
Harshavardhana 10 years ago
parent 701c3e5242
commit eb5aa19dfa
3 changed files with 37 additions and 231 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. 41
      pkg/server/api/api-generic-handlers.go
  2. 152
      pkg/server/config/config.go
  3. 75
      pkg/server/config/config_test.go

41
pkg/server/api/api-generic-handlers.go
Unescape View File

@ -19,10 +19,13 @@ package api
import (
"errors"
"net/http"
"os"
"os/user"
"path/filepath"
"strings"
"time"
"github.com/minio/minio/pkg/server/config"
"github.com/minio/minio/pkg/quick"
"github.com/minio/minio/pkg/utils/crypto/keys"
)
@ -179,18 +182,48 @@ func ValidateAuthHeaderHandler(h http.Handler) http.Handler {
return validateAuthHandler{h}
}
// User context
type User struct {
Version string
Name string
AccessKey string
SecretKey string
}
func getConfigFile() string {
u, err := user.Current()
if err != nil {
return ""
}
confPath := filepath.Join(u.HomeDir, ".minio")
if err := os.MkdirAll(confPath, 0700); err != nil {
return ""
}
return filepath.Join(confPath, "config.json")
}
// validate auth header handler ServeHTTP() wrapper
func (h validateAuthHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
acceptsContentType := getContentType(r)
_, err := stripAuth(r)
switch err.(type) {
case nil:
var conf = config.Config{}
if err := conf.SetupConfig(); err != nil {
users := make(map[string]User)
configFile := getConfigFile()
if configFile == "" {
writeErrorResponse(w, r, InternalError, acceptsContentType, r.URL.Path)
return
}
qconf, err := quick.New(&users)
if err != nil {
writeErrorResponse(w, r, InternalError, acceptsContentType, r.URL.Path)
return
}
if err := qconf.Save(configFile); err != nil {
writeErrorResponse(w, r, InternalError, acceptsContentType, r.URL.Path)
return
}
if err := conf.ReadConfig(); err != nil {
if err := qconf.Load(configFile); err != nil {
writeErrorResponse(w, r, InternalError, acceptsContentType, r.URL.Path)
return
}

152
pkg/server/config/config.go
Unescape View File

@ -1,152 +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 config
import (
"encoding/json"
"io"
"os"
"os/user"
"path/filepath"
"sync"
"github.com/minio/minio/pkg/iodine"
)
// Config context
type Config struct {
ConfigPath string
ConfigFile string
ConfigLock *sync.RWMutex
Users map[string]User
}
// User context
type User struct {
Name string
AccessKey string
SecretKey string
}
// SetupConfig initialize config directory and template config
func (c *Config) SetupConfig() error {
u, err := user.Current()
if err != nil {
return iodine.New(err, nil)
}
confPath := filepath.Join(u.HomeDir, ".minio")
if err := os.MkdirAll(confPath, 0700); err != nil {
return iodine.New(err, nil)
}
c.ConfigPath = confPath
c.ConfigFile = filepath.Join(c.ConfigPath, "config.json")
if _, err := os.Stat(c.ConfigFile); os.IsNotExist(err) {
_, err = os.Create(c.ConfigFile)
if err != nil {
return iodine.New(err, nil)
}
}
c.ConfigLock = new(sync.RWMutex)
return nil
}
// GetConfigPath config file location
func (c *Config) GetConfigPath() string {
return c.ConfigPath
}
// IsUserExists verify if user exists
func (c *Config) IsUserExists(username string) bool {
for _, user := range c.Users {
if user.Name == username {
return true
}
}
return false
}
// GetUser - get user from username
func (c *Config) GetUser(username string) User {
for _, user := range c.Users {
if user.Name == username {
return user
}
}
return User{}
}
// AddUser - add a user into existing User list
func (c *Config) AddUser(user User) {
var currentUsers map[string]User
if len(c.Users) == 0 {
currentUsers = make(map[string]User)
} else {
currentUsers = c.Users
}
currentUsers[user.AccessKey] = user
c.Users = currentUsers
}
// WriteConfig - write encoded json in config file
func (c *Config) WriteConfig() error {
c.ConfigLock.Lock()
defer c.ConfigLock.Unlock()
var file *os.File
var err error
file, err = os.OpenFile(c.ConfigFile, os.O_WRONLY, 0666)
defer file.Close()
if err != nil {
return iodine.New(err, nil)
}
encoder := json.NewEncoder(file)
encoder.Encode(c.Users)
return nil
}
// ReadConfig - read json config file and decode
func (c *Config) ReadConfig() error {
c.ConfigLock.RLock()
defer c.ConfigLock.RUnlock()
var file *os.File
var err error
file, err = os.OpenFile(c.ConfigFile, os.O_RDONLY, 0666)
defer file.Close()
if err != nil {
return iodine.New(err, nil)
}
users := make(map[string]User)
decoder := json.NewDecoder(file)
err = decoder.Decode(&users)
switch err {
case io.EOF:
return nil
case nil:
c.Users = users
return nil
default:
return iodine.New(err, nil)
}
}

75
pkg/server/config/config_test.go
Unescape View File

@ -1,75 +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 config
import (
"io/ioutil"
"os"
"path/filepath"
"sync"
"testing"
. "github.com/minio/check"
"github.com/minio/minio/pkg/utils/crypto/keys"
)
type MySuite struct{}
var _ = Suite(&MySuite{})
func Test(t *testing.T) { TestingT(t) }
func (s *MySuite) TestConfig(c *C) {
conf := Config{}
conf.ConfigLock = new(sync.RWMutex)
conf.ConfigPath, _ = ioutil.TempDir("/tmp", "minio-test-")
defer os.RemoveAll(conf.ConfigPath)
conf.ConfigFile = filepath.Join(conf.ConfigPath, "config.json")
if _, err := os.Stat(conf.ConfigFile); os.IsNotExist(err) {
_, err = os.Create(conf.ConfigFile)
if err != nil {
c.Fatal(err)
}
}
accesskey, _ := keys.GenerateRandomAlphaNumeric(keys.MinioAccessID)
secretkey, _ := keys.GenerateRandomBase64(keys.MinioSecretID)
user := User{
Name: "gnubot",
AccessKey: string(accesskey),
SecretKey: string(secretkey),
}
conf.AddUser(user)
err := conf.WriteConfig()
c.Assert(err, IsNil)
err = conf.ReadConfig()
c.Assert(err, IsNil)
accesskey, _ = keys.GenerateRandomAlphaNumeric(keys.MinioAccessID)
secretkey, _ = keys.GenerateRandomBase64(keys.MinioSecretID)
user = User{
Name: "minio",
AccessKey: string(accesskey),
SecretKey: string(secretkey),
}
conf.AddUser(user)
err = conf.WriteConfig()
c.Assert(err, IsNil)
}
Write Preview
Loading…
Cancel
Save