delete cit to use new gotgt as main cmd, use logrus instead of glog

.gitignore

@@ -42,8 +42,7 @@ _testmain.go
 
 # intellij idea configure
 .idea
-/citadm
+/gotgt
-/citd
 *.out
 examples/*
 *.bak

.travis.yml

@@ -27,7 +27,7 @@ script:
    - dd if=/dev/zero of=/var/tmp/disk.img bs=1024 count=10240
    - mkdir ${HOME}/.gotgt
    - echo '{"storages":[{"deviceID":1000,"path":"file:/var/tmp/disk.img","online":true}],"iscsiportals":[{"id":0,"portal":"127.0.0.1:3260"}],"iscsitargets":{"iqn.2016-09.com.gotgt.gostor:example_tgt_0":{"tpgts":{"1":[0]},"luns":{"0":1000}}}}' > ${HOME}/.gotgt/config.json
-   - ./citd -v 4 1>/dev/null 2>&1 &
+   - ./gotgt daemon --log debug 1>/dev/null 2>&1 &
    # libiscsi test
    - mkdir ${HOME}/libiscsi
    - git clone https://github.com/gostor/libiscsi ${HOME}/libiscsi

Godeps/Godeps.json

@@ -26,10 +26,6 @@
 			"Comment": "v0.2.0-8-g990a1a1",
 			"Rev": "990a1a1a70b0da4c4cb70e117971a4f0babfbf1a"
 		},
-		{
-			"ImportPath": "github.com/golang/glog",
-			"Rev": "23def4e6c14b4da8ac2ed8007337bc5eb5007998"
-		},
 		{
 			"ImportPath": "github.com/gorilla/context",
 			"Rev": "215affda49addc4c8ef7e2534915df2c8c35c6cd"

Godeps/_workspace/src/github.com/golang/glog/LICENSE

@@ -1,191 +0,0 @@
-Apache License
-Version 2.0, January 2004
-http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-"License" shall mean the terms and conditions for use, reproduction, and
-distribution as defined by Sections 1 through 9 of this document.
-
-"Licensor" shall mean the copyright owner or entity authorized by the copyright
-owner that is granting the License.
-
-"Legal Entity" shall mean the union of the acting entity and all other entities
-that control, are controlled by, or are under common control with that entity.
-For the purposes of this definition, "control" means (i) the power, direct or
-indirect, to cause the direction or management of such entity, whether by
-contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
-outstanding shares, or (iii) beneficial ownership of such entity.
-
-"You" (or "Your") shall mean an individual or Legal Entity exercising
-permissions granted by this License.
-
-"Source" form shall mean the preferred form for making modifications, including
-but not limited to software source code, documentation source, and configuration
-files.
-
-"Object" form shall mean any form resulting from mechanical transformation or
-translation of a Source form, including but not limited to compiled object code,
-generated documentation, and conversions to other media types.
-
-"Work" shall mean the work of authorship, whether in Source or Object form, made
-available under the License, as indicated by a copyright notice that is included
-in or attached to the work (an example is provided in the Appendix below).
-
-"Derivative Works" shall mean any work, whether in Source or Object form, that
-is based on (or derived from) the Work and for which the editorial revisions,
-annotations, elaborations, or other modifications represent, as a whole, an
-original work of authorship. For the purposes of this License, Derivative Works
-shall not include works that remain separable from, or merely link (or bind by
-name) to the interfaces of, the Work and Derivative Works thereof.
-
-"Contribution" shall mean any work of authorship, including the original version
-of the Work and any modifications or additions to that Work or Derivative Works
-thereof, that is intentionally submitted to Licensor for inclusion in the Work
-by the copyright owner or by an individual or Legal Entity authorized to submit
-on behalf of the copyright owner. For the purposes of this definition,
-"submitted" means any form of electronic, verbal, or written communication sent
-to the Licensor or its representatives, including but not limited to
-communication on electronic mailing lists, source code control systems, and
-issue tracking systems that are managed by, or on behalf of, the Licensor for
-the purpose of discussing and improving the Work, but excluding communication
-that is conspicuously marked or otherwise designated in writing by the copyright
-owner as "Not a Contribution."
-
-"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
-of whom a Contribution has been received by Licensor and subsequently
-incorporated within the Work.
-
-2. Grant of Copyright License.
-
-Subject to the terms and conditions of this License, each Contributor hereby
-grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
-irrevocable copyright license to reproduce, prepare Derivative Works of,
-publicly display, publicly perform, sublicense, and distribute the Work and such
-Derivative Works in Source or Object form.
-
-3. Grant of Patent License.
-
-Subject to the terms and conditions of this License, each Contributor hereby
-grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
-irrevocable (except as stated in this section) patent license to make, have
-made, use, offer to sell, sell, import, and otherwise transfer the Work, where
-such license applies only to those patent claims licensable by such Contributor
-that are necessarily infringed by their Contribution(s) alone or by combination
-of their Contribution(s) with the Work to which such Contribution(s) was
-submitted. If You institute patent litigation against any entity (including a
-cross-claim or counterclaim in a lawsuit) alleging that the Work or a
-Contribution incorporated within the Work constitutes direct or contributory
-patent infringement, then any patent licenses granted to You under this License
-for that Work shall terminate as of the date such litigation is filed.
-
-4. Redistribution.
-
-You may reproduce and distribute copies of the Work or Derivative Works thereof
-in any medium, with or without modifications, and in Source or Object form,
-provided that You meet the following conditions:
-
-You must give any other recipients of the Work or Derivative Works a copy of
-this License; and
-You must cause any modified files to carry prominent notices stating that You
-changed the files; and
-You must retain, in the Source form of any Derivative Works that You distribute,
-all copyright, patent, trademark, and attribution notices from the Source form
-of the Work, excluding those notices that do not pertain to any part of the
-Derivative Works; and
-If the Work includes a "NOTICE" text file as part of its distribution, then any
-Derivative Works that You distribute must include a readable copy of the
-attribution notices contained within such NOTICE file, excluding those notices
-that do not pertain to any part of the Derivative Works, in at least one of the
-following places: within a NOTICE text file distributed as part of the
-Derivative Works; within the Source form or documentation, if provided along
-with the Derivative Works; or, within a display generated by the Derivative
-Works, if and wherever such third-party notices normally appear. The contents of
-the NOTICE file are for informational purposes only and do not modify the
-License. You may add Your own attribution notices within Derivative Works that
-You distribute, alongside or as an addendum to the NOTICE text from the Work,
-provided that such additional attribution notices cannot be construed as
-modifying the License.
-You may add Your own copyright statement to Your modifications and may provide
-additional or different license terms and conditions for use, reproduction, or
-distribution of Your modifications, or for any such Derivative Works as a whole,
-provided Your use, reproduction, and distribution of the Work otherwise complies
-with the conditions stated in this License.
-
-5. Submission of Contributions.
-
-Unless You explicitly state otherwise, any Contribution intentionally submitted
-for inclusion in the Work by You to the Licensor shall be under the terms and
-conditions of this License, without any additional terms or conditions.
-Notwithstanding the above, nothing herein shall supersede or modify the terms of
-any separate license agreement you may have executed with Licensor regarding
-such Contributions.
-
-6. Trademarks.
-
-This License does not grant permission to use the trade names, trademarks,
-service marks, or product names of the Licensor, except as required for
-reasonable and customary use in describing the origin of the Work and
-reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty.
-
-Unless required by applicable law or agreed to in writing, Licensor provides the
-Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
-including, without limitation, any warranties or conditions of TITLE,
-NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
-solely responsible for determining the appropriateness of using or
-redistributing the Work and assume any risks associated with Your exercise of
-permissions under this License.
-
-8. Limitation of Liability.
-
-In no event and under no legal theory, whether in tort (including negligence),
-contract, or otherwise, unless required by applicable law (such as deliberate
-and grossly negligent acts) or agreed to in writing, shall any Contributor be
-liable to You for damages, including any direct, indirect, special, incidental,
-or consequential damages of any character arising as a result of this License or
-out of the use or inability to use the Work (including but not limited to
-damages for loss of goodwill, work stoppage, computer failure or malfunction, or
-any and all other commercial damages or losses), even if such Contributor has
-been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability.
-
-While redistributing the Work or Derivative Works thereof, You may choose to
-offer, and charge a fee for, acceptance of support, warranty, indemnity, or
-other liability obligations and/or rights consistent with this License. However,
-in accepting such obligations, You may act only on Your own behalf and on Your
-sole responsibility, not on behalf of any other Contributor, and only if You
-agree to indemnify, defend, and hold each Contributor harmless for any liability
-incurred by, or claims asserted against, such Contributor by reason of your
-accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work
-
-To apply the Apache License to your work, attach the following boilerplate
-notice, with the fields enclosed by brackets "[]" replaced with your own
-identifying information. (Don't include the brackets!) The text should be
-enclosed in the appropriate comment syntax for the file format. We also
-recommend that a file or class name and description of purpose be included on
-the same "printed page" as the copyright notice for easier identification within
-third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   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.

Godeps/_workspace/src/github.com/golang/glog/README

@@ -1,44 +0,0 @@
-glog
-====
-
-Leveled execution logs for Go.
-
-This is an efficient pure Go implementation of leveled logs in the
-manner of the open source C++ package
-	https://github.com/google/glog
-
-By binding methods to booleans it is possible to use the log package
-without paying the expense of evaluating the arguments to the log.
-Through the -vmodule flag, the package also provides fine-grained
-control over logging at the file level.
-
-The comment from glog.go introduces the ideas:
-
-	Package glog implements logging analogous to the Google-internal
-	C++ INFO/ERROR/V setup.  It provides functions Info, Warning,
-	Error, Fatal, plus formatting variants such as Infof. It
-	also provides V-style logging controlled by the -v and
-	-vmodule=file=2 flags.
-	
-	Basic examples:
-	
-		glog.Info("Prepare to repel boarders")
-	
-		glog.Fatalf("Initialization failed: %s", err)
-	
-	See the documentation for the V function for an explanation
-	of these examples:
-	
-		if glog.V(2) {
-			glog.Info("Starting transaction...")
-		}
-	
-		glog.V(2).Infoln("Processed", nItems, "elements")
-
-
-The repository contains an open source version of the log package
-used inside Google. The master copy of the source lives inside
-Google, not here. The code in this repo is for export only and is not itself
-under development. Feature requests will be ignored.
-
-Send bug reports to golang-nuts@googlegroups.com.

Godeps/_workspace/src/github.com/golang/glog/glog_file.go

@@ -1,124 +0,0 @@
-// Go support for leveled logs, analogous to https://code.google.com/p/google-glog/
-//
-// Copyright 2013 Google Inc. All Rights Reserved.
-//
-// 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.
-
-// File I/O for logs.
-
-package glog
-
-import (
-	"errors"
-	"flag"
-	"fmt"
-	"os"
-	"os/user"
-	"path/filepath"
-	"strings"
-	"sync"
-	"time"
-)
-
-// MaxSize is the maximum size of a log file in bytes.
-var MaxSize uint64 = 1024 * 1024 * 1800
-
-// logDirs lists the candidate directories for new log files.
-var logDirs []string
-
-// If non-empty, overrides the choice of directory in which to write logs.
-// See createLogDirs for the full list of possible destinations.
-var logDir = flag.String("log_dir", "", "If non-empty, write log files in this directory")
-
-func createLogDirs() {
-	if *logDir != "" {
-		logDirs = append(logDirs, *logDir)
-	}
-	logDirs = append(logDirs, os.TempDir())
-}
-
-var (
-	pid      = os.Getpid()
-	program  = filepath.Base(os.Args[0])
-	host     = "unknownhost"
-	userName = "unknownuser"
-)
-
-func init() {
-	h, err := os.Hostname()
-	if err == nil {
-		host = shortHostname(h)
-	}
-
-	current, err := user.Current()
-	if err == nil {
-		userName = current.Username
-	}
-
-	// Sanitize userName since it may contain filepath separators on Windows.
-	userName = strings.Replace(userName, `\`, "_", -1)
-}
-
-// shortHostname returns its argument, truncating at the first period.
-// For instance, given "www.google.com" it returns "www".
-func shortHostname(hostname string) string {
-	if i := strings.Index(hostname, "."); i >= 0 {
-		return hostname[:i]
-	}
-	return hostname
-}
-
-// logName returns a new log file name containing tag, with start time t, and
-// the name for the symlink for tag.
-func logName(tag string, t time.Time) (name, link string) {
-	name = fmt.Sprintf("%s.%s.%s.log.%s.%04d%02d%02d-%02d%02d%02d.%d",
-		program,
-		host,
-		userName,
-		tag,
-		t.Year(),
-		t.Month(),
-		t.Day(),
-		t.Hour(),
-		t.Minute(),
-		t.Second(),
-		pid)
-	return name, program + "." + tag
-}
-
-var onceLogDirs sync.Once
-
-// create creates a new log file and returns the file and its filename, which
-// contains tag ("INFO", "FATAL", etc.) and t.  If the file is created
-// successfully, create also attempts to update the symlink for that tag, ignoring
-// errors.
-func create(tag string, t time.Time) (f *os.File, filename string, err error) {
-	onceLogDirs.Do(createLogDirs)
-	if len(logDirs) == 0 {
-		return nil, "", errors.New("log: no log dirs")
-	}
-	name, link := logName(tag, t)
-	var lastErr error
-	for _, dir := range logDirs {
-		fname := filepath.Join(dir, name)
-		f, err := os.Create(fname)
-		if err == nil {
-			symlink := filepath.Join(dir, link)
-			os.Remove(symlink)        // ignore err
-			os.Symlink(name, symlink) // ignore err
-			return f, fname, nil
-		}
-		lastErr = err
-	}
-	return nil, "", fmt.Errorf("log: cannot create log: %v", lastErr)
-}

Godeps/_workspace/src/github.com/golang/glog/glog_test.go

@@ -1,415 +0,0 @@
-// Go support for leveled logs, analogous to https://code.google.com/p/google-glog/
-//
-// Copyright 2013 Google Inc. All Rights Reserved.
-//
-// 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 glog
-
-import (
-	"bytes"
-	"fmt"
-	stdLog "log"
-	"path/filepath"
-	"runtime"
-	"strconv"
-	"strings"
-	"testing"
-	"time"
-)
-
-// Test that shortHostname works as advertised.
-func TestShortHostname(t *testing.T) {
-	for hostname, expect := range map[string]string{
-		"":                "",
-		"host":            "host",
-		"host.google.com": "host",
-	} {
-		if got := shortHostname(hostname); expect != got {
-			t.Errorf("shortHostname(%q): expected %q, got %q", hostname, expect, got)
-		}
-	}
-}
-
-// flushBuffer wraps a bytes.Buffer to satisfy flushSyncWriter.
-type flushBuffer struct {
-	bytes.Buffer
-}
-
-func (f *flushBuffer) Flush() error {
-	return nil
-}
-
-func (f *flushBuffer) Sync() error {
-	return nil
-}
-
-// swap sets the log writers and returns the old array.
-func (l *loggingT) swap(writers [numSeverity]flushSyncWriter) (old [numSeverity]flushSyncWriter) {
-	l.mu.Lock()
-	defer l.mu.Unlock()
-	old = l.file
-	for i, w := range writers {
-		logging.file[i] = w
-	}
-	return
-}
-
-// newBuffers sets the log writers to all new byte buffers and returns the old array.
-func (l *loggingT) newBuffers() [numSeverity]flushSyncWriter {
-	return l.swap([numSeverity]flushSyncWriter{new(flushBuffer), new(flushBuffer), new(flushBuffer), new(flushBuffer)})
-}
-
-// contents returns the specified log value as a string.
-func contents(s severity) string {
-	return logging.file[s].(*flushBuffer).String()
-}
-
-// contains reports whether the string is contained in the log.
-func contains(s severity, str string, t *testing.T) bool {
-	return strings.Contains(contents(s), str)
-}
-
-// setFlags configures the logging flags how the test expects them.
-func setFlags() {
-	logging.toStderr = false
-}
-
-// Test that Info works as advertised.
-func TestInfo(t *testing.T) {
-	setFlags()
-	defer logging.swap(logging.newBuffers())
-	Info("test")
-	if !contains(infoLog, "I", t) {
-		t.Errorf("Info has wrong character: %q", contents(infoLog))
-	}
-	if !contains(infoLog, "test", t) {
-		t.Error("Info failed")
-	}
-}
-
-func TestInfoDepth(t *testing.T) {
-	setFlags()
-	defer logging.swap(logging.newBuffers())
-
-	f := func() { InfoDepth(1, "depth-test1") }
-
-	// The next three lines must stay together
-	_, _, wantLine, _ := runtime.Caller(0)
-	InfoDepth(0, "depth-test0")
-	f()
-
-	msgs := strings.Split(strings.TrimSuffix(contents(infoLog), "\n"), "\n")
-	if len(msgs) != 2 {
-		t.Fatalf("Got %d lines, expected 2", len(msgs))
-	}
-
-	for i, m := range msgs {
-		if !strings.HasPrefix(m, "I") {
-			t.Errorf("InfoDepth[%d] has wrong character: %q", i, m)
-		}
-		w := fmt.Sprintf("depth-test%d", i)
-		if !strings.Contains(m, w) {
-			t.Errorf("InfoDepth[%d] missing %q: %q", i, w, m)
-		}
-
-		// pull out the line number (between : and ])
-		msg := m[strings.LastIndex(m, ":")+1:]
-		x := strings.Index(msg, "]")
-		if x < 0 {
-			t.Errorf("InfoDepth[%d]: missing ']': %q", i, m)
-			continue
-		}
-		line, err := strconv.Atoi(msg[:x])
-		if err != nil {
-			t.Errorf("InfoDepth[%d]: bad line number: %q", i, m)
-			continue
-		}
-		wantLine++
-		if wantLine != line {
-			t.Errorf("InfoDepth[%d]: got line %d, want %d", i, line, wantLine)
-		}
-	}
-}
-
-func init() {
-	CopyStandardLogTo("INFO")
-}
-
-// Test that CopyStandardLogTo panics on bad input.
-func TestCopyStandardLogToPanic(t *testing.T) {
-	defer func() {
-		if s, ok := recover().(string); !ok || !strings.Contains(s, "LOG") {
-			t.Errorf(`CopyStandardLogTo("LOG") should have panicked: %v`, s)
-		}
-	}()
-	CopyStandardLogTo("LOG")
-}
-
-// Test that using the standard log package logs to INFO.
-func TestStandardLog(t *testing.T) {
-	setFlags()
-	defer logging.swap(logging.newBuffers())
-	stdLog.Print("test")
-	if !contains(infoLog, "I", t) {
-		t.Errorf("Info has wrong character: %q", contents(infoLog))
-	}
-	if !contains(infoLog, "test", t) {
-		t.Error("Info failed")
-	}
-}
-
-// Test that the header has the correct format.
-func TestHeader(t *testing.T) {
-	setFlags()
-	defer logging.swap(logging.newBuffers())
-	defer func(previous func() time.Time) { timeNow = previous }(timeNow)
-	timeNow = func() time.Time {
-		return time.Date(2006, 1, 2, 15, 4, 5, .067890e9, time.Local)
-	}
-	pid = 1234
-	Info("test")
-	var line int
-	format := "I0102 15:04:05.067890    1234 glog_test.go:%d] test\n"
-	n, err := fmt.Sscanf(contents(infoLog), format, &line)
-	if n != 1 || err != nil {
-		t.Errorf("log format error: %d elements, error %s:\n%s", n, err, contents(infoLog))
-	}
-	// Scanf treats multiple spaces as equivalent to a single space,
-	// so check for correct space-padding also.
-	want := fmt.Sprintf(format, line)
-	if contents(infoLog) != want {
-		t.Errorf("log format error: got:\n\t%q\nwant:\t%q", contents(infoLog), want)
-	}
-}
-
-// Test that an Error log goes to Warning and Info.
-// Even in the Info log, the source character will be E, so the data should
-// all be identical.
-func TestError(t *testing.T) {
-	setFlags()
-	defer logging.swap(logging.newBuffers())
-	Error("test")
-	if !contains(errorLog, "E", t) {
-		t.Errorf("Error has wrong character: %q", contents(errorLog))
-	}
-	if !contains(errorLog, "test", t) {
-		t.Error("Error failed")
-	}
-	str := contents(errorLog)
-	if !contains(warningLog, str, t) {
-		t.Error("Warning failed")
-	}
-	if !contains(infoLog, str, t) {
-		t.Error("Info failed")
-	}
-}
-
-// Test that a Warning log goes to Info.
-// Even in the Info log, the source character will be W, so the data should
-// all be identical.
-func TestWarning(t *testing.T) {
-	setFlags()
-	defer logging.swap(logging.newBuffers())
-	Warning("test")
-	if !contains(warningLog, "W", t) {
-		t.Errorf("Warning has wrong character: %q", contents(warningLog))
-	}
-	if !contains(warningLog, "test", t) {
-		t.Error("Warning failed")
-	}
-	str := contents(warningLog)
-	if !contains(infoLog, str, t) {
-		t.Error("Info failed")
-	}
-}
-
-// Test that a V log goes to Info.
-func TestV(t *testing.T) {
-	setFlags()
-	defer logging.swap(logging.newBuffers())
-	logging.verbosity.Set("2")
-	defer logging.verbosity.Set("0")
-	V(2).Info("test")
-	if !contains(infoLog, "I", t) {
-		t.Errorf("Info has wrong character: %q", contents(infoLog))
-	}
-	if !contains(infoLog, "test", t) {
-		t.Error("Info failed")
-	}
-}
-
-// Test that a vmodule enables a log in this file.
-func TestVmoduleOn(t *testing.T) {
-	setFlags()
-	defer logging.swap(logging.newBuffers())
-	logging.vmodule.Set("glog_test=2")
-	defer logging.vmodule.Set("")
-	if !V(1) {
-		t.Error("V not enabled for 1")
-	}
-	if !V(2) {
-		t.Error("V not enabled for 2")
-	}
-	if V(3) {
-		t.Error("V enabled for 3")
-	}
-	V(2).Info("test")
-	if !contains(infoLog, "I", t) {
-		t.Errorf("Info has wrong character: %q", contents(infoLog))
-	}
-	if !contains(infoLog, "test", t) {
-		t.Error("Info failed")
-	}
-}
-
-// Test that a vmodule of another file does not enable a log in this file.
-func TestVmoduleOff(t *testing.T) {
-	setFlags()
-	defer logging.swap(logging.newBuffers())
-	logging.vmodule.Set("notthisfile=2")
-	defer logging.vmodule.Set("")
-	for i := 1; i <= 3; i++ {
-		if V(Level(i)) {
-			t.Errorf("V enabled for %d", i)
-		}
-	}
-	V(2).Info("test")
-	if contents(infoLog) != "" {
-		t.Error("V logged incorrectly")
-	}
-}
-
-// vGlobs are patterns that match/don't match this file at V=2.
-var vGlobs = map[string]bool{
-	// Easy to test the numeric match here.
-	"glog_test=1": false, // If -vmodule sets V to 1, V(2) will fail.
-	"glog_test=2": true,
-	"glog_test=3": true, // If -vmodule sets V to 1, V(3) will succeed.
-	// These all use 2 and check the patterns. All are true.
-	"*=2":           true,
-	"?l*=2":         true,
-	"????_*=2":      true,
-	"??[mno]?_*t=2": true,
-	// These all use 2 and check the patterns. All are false.
-	"*x=2":         false,
-	"m*=2":         false,
-	"??_*=2":       false,
-	"?[abc]?_*t=2": false,
-}
-
-// Test that vmodule globbing works as advertised.
-func testVmoduleGlob(pat string, match bool, t *testing.T) {
-	setFlags()
-	defer logging.swap(logging.newBuffers())
-	defer logging.vmodule.Set("")
-	logging.vmodule.Set(pat)
-	if V(2) != Verbose(match) {
-		t.Errorf("incorrect match for %q: got %t expected %t", pat, V(2), match)
-	}
-}
-
-// Test that a vmodule globbing works as advertised.
-func TestVmoduleGlob(t *testing.T) {
-	for glob, match := range vGlobs {
-		testVmoduleGlob(glob, match, t)
-	}
-}
-
-func TestRollover(t *testing.T) {
-	setFlags()
-	var err error
-	defer func(previous func(error)) { logExitFunc = previous }(logExitFunc)
-	logExitFunc = func(e error) {
-		err = e
-	}
-	defer func(previous uint64) { MaxSize = previous }(MaxSize)
-	MaxSize = 512
-
-	Info("x") // Be sure we have a file.
-	info, ok := logging.file[infoLog].(*syncBuffer)
-	if !ok {
-		t.Fatal("info wasn't created")
-	}
-	if err != nil {
-		t.Fatalf("info has initial error: %v", err)
-	}
-	fname0 := info.file.Name()
-	Info(strings.Repeat("x", int(MaxSize))) // force a rollover
-	if err != nil {
-		t.Fatalf("info has error after big write: %v", err)
-	}
-
-	// Make sure the next log file gets a file name with a different
-	// time stamp.
-	//
-	// TODO: determine whether we need to support subsecond log
-	// rotation.  C++ does not appear to handle this case (nor does it
-	// handle Daylight Savings Time properly).
-	time.Sleep(1 * time.Second)
-
-	Info("x") // create a new file
-	if err != nil {
-		t.Fatalf("error after rotation: %v", err)
-	}
-	fname1 := info.file.Name()
-	if fname0 == fname1 {
-		t.Errorf("info.f.Name did not change: %v", fname0)
-	}
-	if info.nbytes >= MaxSize {
-		t.Errorf("file size was not reset: %d", info.nbytes)
-	}
-}
-
-func TestLogBacktraceAt(t *testing.T) {
-	setFlags()
-	defer logging.swap(logging.newBuffers())
-	// The peculiar style of this code simplifies line counting and maintenance of the
-	// tracing block below.
-	var infoLine string
-	setTraceLocation := func(file string, line int, ok bool, delta int) {
-		if !ok {
-			t.Fatal("could not get file:line")
-		}
-		_, file = filepath.Split(file)
-		infoLine = fmt.Sprintf("%s:%d", file, line+delta)
-		err := logging.traceLocation.Set(infoLine)
-		if err != nil {
-			t.Fatal("error setting log_backtrace_at: ", err)
-		}
-	}
-	{
-		// Start of tracing block. These lines know about each other's relative position.
-		_, file, line, ok := runtime.Caller(0)
-		setTraceLocation(file, line, ok, +2) // Two lines between Caller and Info calls.
-		Info("we want a stack trace here")
-	}
-	numAppearances := strings.Count(contents(infoLog), infoLine)
-	if numAppearances < 2 {
-		// Need 2 appearances, one in the log header and one in the trace:
-		//   log_test.go:281: I0511 16:36:06.952398 02238 log_test.go:280] we want a stack trace here
-		//   ...
-		//   github.com/glog/glog_test.go:280 (0x41ba91)
-		//   ...
-		// We could be more precise but that would require knowing the details
-		// of the traceback format, which may not be dependable.
-		t.Fatal("got no trace back; log is ", contents(infoLog))
-	}
-}
-
-func BenchmarkHeader(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		buf, _, _ := logging.header(infoLog, 0)
-		logging.putBuffer(buf)
-	}
-}

Makefile.am

@@ -1,13 +1,10 @@
 export GOPATH:=$(abs_top_srcdir)/Godeps/_workspace:$(GOPATH)
 
-all-local: build-cli build-daemon
+all-local: build
 clean-local:
-	-rm -f citadm citd
+	-rm -f gotgt
 install-exec-local: 
-	$(INSTALL_PROGRAM) citadm $(bindir)
+	$(INSTALL_PROGRAM) gotgt $(bindir)
-	$(INSTALL_PROGRAM) citd $(bindir)
 
-build-cli:
+build:
-	go build citadm.go
+	go build gotgt.go
-build-daemon:
-	go build citd.go

README.md

@@ -1,6 +1,6 @@
 ## gotgt [![Build Status](https://travis-ci.org/gostor/gotgt.svg)](https://travis-ci.org/gostor/gotgt)
 
-Simple Golang SCSI Target framework, this includes two binaries, one is `citadm` which is command line to config and control, the other is `citd` which is a target daemon.
+Simple Golang SCSI Target framework, this includes only one binary, you can start a daemon via `gotgt daemon` and control it via `gotgt list/create/rm`.
 
 ## Build
 

cmd/cmd.go

@@ -1,3 +1,19 @@
+/*
+Copyright 2016 The GoStor Authors All rights reserved.
+
+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 cmd
 
 import (
@@ -10,7 +26,7 @@ import (
 
 func NewCommand(cli *client.Client) *cobra.Command {
 	var cmd = &cobra.Command{
-		Use:   "citadm",
+		Use:   "gotgt",
 		Short: "Gotgt is a very fast and stable SCSI target framework",
 		Long:  ``,
 		Run: func(cmd *cobra.Command, args []string) {
@@ -18,6 +34,7 @@ func NewCommand(cli *client.Client) *cobra.Command {
 		},
 	}
 	cmd.AddCommand(
+		newDaemonCommand(cli),
 		newCreateCommand(cli),
 		newRemoveCommand(cli),
 		newListCommand(cli),

cmd/daemon.go

@@ -14,11 +14,9 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// SCSI target daemon
+package cmd
-package main
 
 import (
-	"flag"
 	"fmt"
 	"os"
 	"os/signal"
@@ -26,53 +24,65 @@ import (
 	"strings"
 	"syscall"
 
-	"github.com/golang/glog"
+	log "github.com/Sirupsen/logrus"
+	"github.com/gostor/gotgt/pkg/api/client"
 	"github.com/gostor/gotgt/pkg/apiserver"
 	"github.com/gostor/gotgt/pkg/config"
 	_ "github.com/gostor/gotgt/pkg/port/iscsit"
 	"github.com/gostor/gotgt/pkg/scsi"
 	_ "github.com/gostor/gotgt/pkg/scsi/backingstore"
+	"github.com/spf13/cobra"
 )
 
-func main() {
+func newDaemonCommand(cli *client.Client) *cobra.Command {
-
+	var host string
-	flHelp := flag.Bool("help", false, "Print help message for Hyperd daemon")
+	var driver string
-	flHost := flag.String("host", "tcp://127.0.0.1:23457", "Host for SCSI target daemon")
+	var logLevel string
-	flDriver := flag.String("driver", "iscsi", "SCSI low level driver")
+	var cmd = &cobra.Command{
-	flag.Usage = func() { *flHelp = true }
+		Use:   "daemon",
-	flag.Parse()
+		Short: "Setup a daemon",
-	flag.Set("logtostderr", "true")
+		Long:  `Setup the Gotgt's daemon`,
-	if *flHelp == true {
+		RunE: func(cmd *cobra.Command, args []string) error {
-		fmt.Println(`Usage:
+			return createDaemon(host, driver, logLevel)
-  xxxd [OPTIONS]
+		},
-
-Application Options:
-  --host=""                 Host for SCSI target daemon
-  --driver=iscsi            SCSI low level driver
-
-Help Options:
-  -h, --help                Show this help message
-`)
-		return
 	}
+	flags := cmd.Flags()
+	flags.StringVar(&logLevel, "log", "info", "Log level of SCSI target daemon")
+	flags.StringVar(&host, "host", "tcp://127.0.0.1:23457", "Host for SCSI target daemon")
+	flags.StringVar(&driver, "driver", "iscsi", "SCSI low level driver")
+	return cmd
+}
 
+func createDaemon(host, driver, level string) error {
+	switch level {
+	case "info":
+		log.SetLevel(log.InfoLevel)
+	case "warn":
+		log.SetLevel(log.WarnLevel)
+	case "debug":
+		log.SetLevel(log.DebugLevel)
+	case "panic", "fatal", "error":
+		log.SetLevel(log.ErrorLevel)
+	default:
+		return fmt.Errorf("unknown log level: %v", level)
+	}
 	config, err := config.Load(config.ConfigDir())
 	if err != nil {
-		glog.Error(err)
+		log.Error(err)
-		os.Exit(1)
+		return err
 	}
 
 	err = scsi.InitSCSILUMap(config)
 	if err != nil {
-		glog.Error(err)
+		log.Error(err)
-		os.Exit(1)
+		return err
 	}
 
 	scsiTarget := scsi.NewSCSITargetService()
-	targetDriver, err := scsi.NewTargetDriver(*flDriver, scsiTarget)
+	targetDriver, err := scsi.NewTargetDriver(driver, scsiTarget)
 	if err != nil {
-		glog.Error(err)
+		log.Error(err)
-		os.Exit(1)
+		return err
 	}
 
 	for tgtname := range config.ISCSITargets {
@@ -88,22 +98,23 @@ Help Options:
 	}
 
 	hosts := []string{}
-	if *flHost != "" {
+	if host != "" {
-		hosts = append(hosts, *flHost)
+		hosts = append(hosts, host)
 	}
 	for _, protoAddr := range hosts {
 		protoAddrParts := strings.SplitN(protoAddr, "://", 2)
 		if len(protoAddrParts) != 2 {
-			glog.Errorf("bad format %s, expected PROTO://ADDR", protoAddr)
+			err = fmt.Errorf("bad format %s, expected PROTO://ADDR", protoAddr)
-			return
+			log.Error(err)
+			return err
 		}
 		serverConfig.Addrs = append(serverConfig.Addrs, apiserver.Addr{Proto: protoAddrParts[0], Addr: protoAddrParts[1]})
 	}
 
 	s, err := apiserver.New(serverConfig)
 	if err != nil {
-		glog.Errorf(err.Error())
+		log.Error(err)
-		return
+		return err
 	}
 	s.InitRouters()
 	// The serve API routine never exits unless an error occurs
@@ -122,10 +133,11 @@ Help Options:
 		// If we have an error here it is unique to API (as daemonErr would have
 		// exited the daemon process above)
 		if errAPI != nil {
-			glog.Warningf("Shutting down due to ServeAPI error: %v", errAPI)
+			log.Warnf("Shutting down due to ServeAPI error: %v", errAPI)
 		}
 	case <-stopAll:
 		break
 	}
 	s.Close()
+	return nil
 }

gotgt.go

@@ -25,9 +25,11 @@ import (
 	"github.com/docker/go-connections/sockets"
 	"github.com/gostor/gotgt/cmd"
 	"github.com/gostor/gotgt/pkg/api/client"
+	"github.com/gostor/gotgt/pkg/version"
 )
 
 func main() {
+
 	host := "tcp://127.0.0.1:23457"
 	httpClient, err := newHTTPClient(host)
 	if err != nil {
@@ -35,7 +37,7 @@ func main() {
 		os.Exit(1)
 	}
 
-	cli, err := client.NewClient(host, "0.1", httpClient, nil)
+	cli, err := client.NewClient(host, version.Version, httpClient, nil)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "%v", err)
 		os.Exit(1)

pkg/apiserver/apiserver.go

@@ -25,9 +25,9 @@ import (
 	"strconv"
 	"strings"
 
+	log "github.com/Sirupsen/logrus"
 	systemdActivation "github.com/coreos/go-systemd/activation"
 	"github.com/docker/go-connections/sockets"
-	"github.com/golang/glog"
 	"github.com/gorilla/mux"
 	"github.com/gostor/gotgt/pkg/apiserver/httputils"
 	"github.com/gostor/gotgt/pkg/apiserver/router"
@@ -79,7 +79,7 @@ func New(cfg *Config) (*Server, error) {
 		if err != nil {
 			return nil, err
 		}
-		glog.V(3).Infof("Server created for HTTP on %s (%s)", addr.Proto, addr.Addr)
+		log.Infof("Server created for HTTP on %s (%s)", addr.Proto, addr.Addr)
 		s.servers = append(s.servers, srv...)
 	}
 	return s, nil
@@ -89,7 +89,7 @@ func New(cfg *Config) (*Server, error) {
 func (s *Server) Close() {
 	for _, srv := range s.servers {
 		if err := srv.Close(); err != nil {
-			glog.Error(err)
+			log.Error(err)
 		}
 	}
 }
@@ -104,7 +104,7 @@ func (s *Server) serveAPI() error {
 		srv.srv.Handler = s.routerSwapper
 		go func(srv *HTTPServer) {
 			var err error
-			glog.V(3).Infof("API listen on %s", srv.l.Addr())
+			log.Infof("API listen on %s", srv.l.Addr())
 			if err = srv.Serve(); err != nil && strings.Contains(err.Error(), "use of closed network connection") {
 				err = nil
 			}
@@ -142,7 +142,7 @@ func (s *HTTPServer) Close() error {
 
 func (s *Server) initTCPSocket(addr string) (l net.Listener, err error) {
 	if s.cfg.TLSConfig == nil || s.cfg.TLSConfig.ClientAuth != tls.RequireAndVerifyClientCert {
-		glog.Warning("/!\\ DON'T BIND ON ANY IP ADDRESS WITHOUT setting -tlsverify IF YOU DON'T KNOW WHAT YOU'RE DOING /!\\")
+		log.Warning("/!\\ DON'T BIND ON ANY IP ADDRESS WITHOUT setting -tlsverify IF YOU DON'T KNOW WHAT YOU'RE DOING /!\\")
 	}
 	if l, err = sockets.NewTCPSocket(addr, s.cfg.TLSConfig); err != nil {
 		return nil, err
@@ -154,7 +154,7 @@ func (s *Server) initTCPSocket(addr string) (l net.Listener, err error) {
 func (s *Server) makeHTTPHandler(handler httputils.APIFunc) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		// log the handler call
-		glog.V(3).Infof("Calling %s %s", r.Method, r.URL.Path)
+		log.Infof("Calling %s %s", r.Method, r.URL.Path)
 
 		// Define the context that we'll pass around to share info
 		// like the docker-request-id.
@@ -172,7 +172,7 @@ func (s *Server) makeHTTPHandler(handler httputils.APIFunc) http.HandlerFunc {
 		}
 
 		if err := handlerFunc(ctx, w, r, vars); err != nil {
-			glog.Errorf("Handler for %s %s returned error: %v", r.Method, r.URL.Path, err)
+			log.Errorf("Handler for %s %s returned error: %v", r.Method, r.URL.Path, err)
 			httputils.WriteError(w, err)
 		}
 	}
@@ -195,12 +195,12 @@ func (s *Server) addRouter(r router.Router) {
 func (s *Server) createMux() *mux.Router {
 	m := mux.NewRouter()
 
-	glog.V(3).Infof("Registering routers")
+	log.Infof("Registering routers")
 	for _, apiRouter := range s.routers {
 		for _, r := range apiRouter.Routes() {
 			f := s.makeHTTPHandler(r.Handler())
 
-			glog.V(3).Infof("Registering %s, %s", r.Method(), r.Path())
+			log.Infof("Registering %s, %s", r.Method(), r.Path())
 			m.Path(versionMatcher + r.Path()).Methods(r.Method()).Handler(f)
 			m.Path(r.Path()).Methods(r.Method()).Handler(f)
 		}
@@ -214,7 +214,7 @@ func (s *Server) createMux() *mux.Router {
 // the API execution.
 func (s *Server) Wait(waitChan chan error) {
 	if err := s.serveAPI(); err != nil {
-		glog.Errorf("ServeAPI error: %v", err)
+		log.Errorf("ServeAPI error: %v", err)
 		waitChan <- err
 		return
 	}
@@ -307,7 +307,7 @@ func listenFD(addr string, tlsConfig *tls.Config) ([]net.Listener, error) {
 			continue
 		}
 		if err := ls.Close(); err != nil {
-			glog.Errorf("Failed to close systemd activated file at fd %d: %v", fdOffset+3, err)
+			log.Errorf("Failed to close systemd activated file at fd %d: %v", fdOffset+3, err)
 		}
 	}
 	return []net.Listener{listeners[fdOffset]}, nil

pkg/port/iscsit/iscsid.go

@@ -23,7 +23,7 @@ import (
 	"os"
 	"strconv"
 
-	"github.com/golang/glog"
+	log "github.com/Sirupsen/logrus"
 	"github.com/gostor/gotgt/pkg/api"
 	"github.com/gostor/gotgt/pkg/config"
 	"github.com/gostor/gotgt/pkg/scsi"
@@ -124,25 +124,25 @@ func (s *ISCSITargetDriver) HasPortal(tgtName string, tpgt uint16, portal string
 func (s *ISCSITargetDriver) Run() error {
 	l, err := net.Listen("tcp", ":3260")
 	if err != nil {
-		glog.Error(err)
+		log.Error(err)
 		os.Exit(1)
 	}
 	defer l.Close()
 
 	for {
-		glog.Info("Listening ...")
+		log.Info("Listening ...")
 		conn, err := l.Accept()
 		if err != nil {
-			glog.Error(err)
+			log.Error(err)
 			continue
 		}
-		glog.Info(conn.LocalAddr().String())
+		log.Info(conn.LocalAddr().String())
-		glog.Info("Accepting ...")
+		log.Info("Accepting ...")
 		iscsiConn := &iscsiConnection{conn: conn}
 		iscsiConn.init()
 		iscsiConn.rxIOState = IOSTATE_RX_BHS
 
-		glog.Infof("connection is connected from %s...\n", conn.RemoteAddr().String())
+		log.Infof("connection is connected from %s...\n", conn.RemoteAddr().String())
 		// start a new thread to do with this command
 		go s.handler(DATAIN, iscsiConn)
 	}
@@ -152,15 +152,15 @@ func (s *ISCSITargetDriver) Run() error {
 func (s *ISCSITargetDriver) handler(events byte, conn *iscsiConnection) {
 
 	if events&DATAIN != 0 {
-		glog.V(1).Infof("rx handler processing...")
+		log.Debug("rx handler processing...")
 		go s.rxHandler(conn)
 	}
 	if conn.state != CONN_STATE_CLOSE && events&DATAOUT != 0 {
-		glog.V(1).Infof("tx handler processing...")
+		log.Debug("tx handler processing...")
 		s.txHandler(conn)
 	}
 	if conn.state == CONN_STATE_CLOSE {
-		glog.Warningf("iscsi connection[%d] closed", conn.CID)
+		log.Warningf("iscsi connection[%d] closed", conn.CID)
 		conn.close()
 	}
 }
@@ -181,22 +181,22 @@ func (s *ISCSITargetDriver) rxHandler(conn *iscsiConnection) {
 	for {
 		switch conn.rxIOState {
 		case IOSTATE_RX_BHS:
-			glog.Infof("rx handler: IOSTATE_RX_BHS")
+			log.Debug("rx handler: IOSTATE_RX_BHS")
 			buf, length, err := conn.readData(BHS_SIZE)
 			if err != nil {
-				glog.Error(err)
+				log.Error(err)
 				return
 			}
 			if length == 0 {
-				glog.Warningf("set connection to close")
+				log.Warningf("set connection to close")
 				conn.state = CONN_STATE_CLOSE
 				return
 			}
 			conn.rxBuffer = buf
 			cmd, err = parseHeader(buf)
 			if err != nil {
-				glog.Error(err)
+				log.Error(err)
-				glog.Warningf("set connection to close")
+				log.Warningf("set connection to close")
 				conn.state = CONN_STATE_CLOSE
 				return
 			}
@@ -205,8 +205,8 @@ func (s *ISCSITargetDriver) rxHandler(conn *iscsiConnection) {
 				conn.rxIOState = IOSTATE_RX_INIT_AHS
 				break
 			}
-			glog.V(2).Infof("got command: \n%s", cmd.String())
+			log.Debugf("got command: \n%s", cmd.String())
-			glog.V(2).Infof("got buffer: %v", buf)
+			log.Debugf("got buffer: %v", buf)
 			final = true
 		case IOSTATE_RX_INIT_AHS:
 			conn.rxIOState = IOSTATE_RX_DATA
@@ -227,24 +227,24 @@ func (s *ISCSITargetDriver) rxHandler(conn *iscsiConnection) {
 			for length < dl {
 				b, l, err := conn.readData(dl - length)
 				if err != nil {
-					glog.Error(err)
+					log.Error(err)
 					return
 				}
 				length += l
 				buf = append(buf, b...)
 			}
 			if length != dl {
-				glog.V(2).Infof("get length is %d, but expected %d", length, dl)
+				log.Debugf("get length is %d, but expected %d", length, dl)
-				glog.Warningf("set connection to close")
+				log.Warning("set connection to close")
 				conn.state = CONN_STATE_CLOSE
 				return
 			}
 			cmd.RawData = buf[:length]
 			conn.rxBuffer = append(conn.rxBuffer, buf...)
 			final = true
-			glog.Infof("got command: \n%s", cmd.String())
+			log.Debugf("got command: \n%s", cmd.String())
 		default:
-			glog.Errorf("error %d %d\n", conn.state, conn.rxIOState)
+			log.Errorf("error %d %d\n", conn.state, conn.rxIOState)
 			return
 		}
 
@@ -260,29 +260,29 @@ func (s *ISCSITargetDriver) rxHandler(conn *iscsiConnection) {
 		conn.resp = &ISCSICommand{}
 		switch conn.req.OpCode {
 		case OpLoginReq:
-			glog.Infof("OpLoginReq")
+			log.Debug("OpLoginReq")
 			if err := s.iscsiExecLogin(conn); err != nil {
-				glog.Error(err)
+				log.Error(err)
-				glog.Warningf("set connection to close")
+				log.Warningf("set connection to close")
 				conn.state = CONN_STATE_CLOSE
 			}
 		case OpLogoutReq:
-			glog.Infof("OpLogoutReq")
+			log.Debug("OpLogoutReq")
 			if err := iscsiExecLogout(conn); err != nil {
-				glog.Warningf("set connection to close")
+				log.Warningf("set connection to close")
 				conn.state = CONN_STATE_CLOSE
 			}
 		case OpTextReq:
-			glog.Infof("OpTextReq")
+			log.Debug("OpTextReq")
 			if err := s.iscsiExecText(conn); err != nil {
-				glog.Warningf("set connection to close")
+				log.Warningf("set connection to close")
 				conn.state = CONN_STATE_CLOSE
 			}
 		default:
 			iscsiExecReject(conn)
 		}
-		glog.V(2).Infof("connection state is %v", conn.state)
+		log.Debugf("connection state is %v", conn.state)
-		glog.V(2).Infof("%#v", conn.resp.String())
+		log.Debugf("%#v", conn.resp.String())
 		s.handler(DATAOUT, conn)
 	}
 }
@@ -374,7 +374,7 @@ func (s *ISCSITargetDriver) iscsiExecLogin(conn *iscsiConnection) error {
 			// create a new session
 			sess, err := s.NewISCSISession(conn, cmd.ISID)
 			if err != nil {
-				glog.Error(err)
+				log.Error(err)
 				return err
 			}
 			itnexus := &api.ITNexus{uuid.NewV1(), GeniSCSIITNexusID(sess)}
@@ -413,8 +413,8 @@ func (s *ISCSITargetDriver) iscsiExecText(conn *iscsiConnection) error {
 	if st, ok := keys["SendTargets"]; ok {
 		if st == "All" {
 			for name, tgt := range s.iSCSITargets {
-				glog.V(2).Infof("iscsi target: %v", name)
+				log.Debugf("iscsi target: %v", name)
-				//glog.V(2).Infof("iscsi target portals: %v", tgt.Portals)
+				//log.Debugf("iscsi target portals: %v", tgt.Portals)
 
 				result = append(result, util.KeyValue{"TargetName", name})
 				for _, tpgt := range tgt.TPGTs {
@@ -512,23 +512,23 @@ func (s *ISCSITargetDriver) txHandler(conn *iscsiConnection) {
 	if conn.state == CONN_STATE_SCSI && conn.txTask == nil {
 		err := s.scsiCommandHandler(conn)
 		if err != nil {
-			glog.Error(err)
+			log.Error(err)
 			return
 		}
 	}
 	for {
 		switch conn.txIOState {
 		case IOSTATE_TX_BHS:
-			glog.V(2).Infof("ready to write response")
+			log.Debug("ready to write response")
-			glog.V(2).Infof("%s", conn.resp.String())
+			log.Debugf("%s", conn.resp.String())
-			glog.V(2).Infof("length of RawData is %d", len(conn.resp.RawData))
+			log.Debugf("length of RawData is %d", len(conn.resp.RawData))
-			glog.V(2).Infof("length of resp is %d", len(conn.resp.Bytes()))
+			log.Debugf("length of resp is %d", len(conn.resp.Bytes()))
 			if l, err := conn.write(conn.resp.Bytes()); err != nil {
-				glog.Error(err)
+				log.Error(err)
 				return
 			} else {
 				conn.txIOState = IOSTATE_TX_INIT_AHS
-				glog.V(2).Infof("success to write %d length", l)
+				log.Debugf("success to write %d length", l)
 			}
 		case IOSTATE_TX_INIT_AHS:
 			if hdigest != 0 {
@@ -547,7 +547,7 @@ func (s *ISCSITargetDriver) txHandler(conn *iscsiConnection) {
 				conn.txIOState = IOSTATE_TX_INIT_DDIGEST
 			}
 		default:
-			glog.Errorf("error %d %d\n", conn.state, conn.txIOState)
+			log.Errorf("error %d %d\n", conn.state, conn.txIOState)
 			return
 		}
 
@@ -556,41 +556,41 @@ func (s *ISCSITargetDriver) txHandler(conn *iscsiConnection) {
 		}
 	}
 
-	glog.V(3).Infof("connection state: %d", conn.state)
+	log.Debugf("connection state: %d", conn.state)
 	switch conn.state {
 	case CONN_STATE_CLOSE, CONN_STATE_EXIT:
-		glog.Warningf("set connection to close")
+		log.Warnf("set connection to close")
 		conn.state = CONN_STATE_CLOSE
 	case CONN_STATE_SECURITY_LOGIN:
 		conn.state = CONN_STATE_LOGIN
-		glog.V(3).Infof("CONN_STATE_LOGIN")
+		log.Debugf("CONN_STATE_LOGIN")
 	case CONN_STATE_SECURITY_FULL, CONN_STATE_LOGIN_FULL:
 		if conn.sessionType == SESSION_NORMAL {
 			conn.state = CONN_STATE_KERNEL
-			glog.Infof("CONN_STATE_KERNEL")
+			log.Infof("CONN_STATE_KERNEL")
 			conn.state = CONN_STATE_SCSI
-			glog.V(3).Infof("CONN_STATE_SCSI")
+			log.Debugf("CONN_STATE_SCSI")
 		} else {
 			conn.state = CONN_STATE_FULL
-			glog.V(3).Infof("CONN_STATE_FULL")
+			log.Debugf("CONN_STATE_FULL")
 		}
 		conn.rxIOState = IOSTATE_RX_BHS
 		s.handler(DATAIN, conn)
 	case CONN_STATE_SCSI:
 		conn.txTask = nil
 	default:
-		glog.Warningf("unexpected connection state: %d", conn.state)
+		log.Warnf("unexpected connection state: %d", conn.state)
 		conn.rxIOState = IOSTATE_RX_BHS
 		s.handler(DATAIN, conn)
 	}
-	glog.Infof("%d", conn.state)
+	log.Infof("%d", conn.state)
 }
 
 func (s *ISCSITargetDriver) scsiCommandHandler(conn *iscsiConnection) (err error) {
 	req := conn.req
 	switch req.OpCode {
 	case OpSCSICmd:
-		glog.V(2).Infof("SCSI Command processing...")
+		log.Debugf("SCSI Command processing...")
 		scmd := &api.SCSICommand{}
 		task := &iscsiTask{conn: conn, cmd: conn.req, tag: conn.req.TaskTag, scmd: scmd}
 		if req.Write {
@@ -599,7 +599,7 @@ func (s *ISCSITargetDriver) scsiCommandHandler(conn *iscsiConnection) (err error
 			if !req.Final {
 				task.unsolCount = 1
 			}
-			glog.V(2).Infof("SCSI write, R2T count: %d, unsol Count: %d, offset: %d", task.r2tCount, task.unsolCount, task.offset)
+			log.Debugf("SCSI write, R2T count: %d, unsol Count: %d, offset: %d", task.r2tCount, task.unsolCount, task.offset)
 
 			if task.scmd.OutSDBBuffer.Buffer == nil {
 				task.scmd.OutSDBBuffer.Buffer = bytes.NewBuffer([]byte{})
@@ -667,7 +667,7 @@ func (s *ISCSITargetDriver) scsiCommandHandler(conn *iscsiConnection) (err error
 		conn.txIOState = IOSTATE_TX_BHS
 		iscsiExecTMFunction(conn)
 	case OpSCSIOut:
-		glog.V(1).Infof("iSCSI Data-out processing...")
+		log.Debugf("iSCSI Data-out processing...")
 		var task *iscsiTask
 		for _, t := range conn.session.PendingTasks {
 			if t.tag == conn.req.TaskTag {
@@ -676,16 +676,16 @@ func (s *ISCSITargetDriver) scsiCommandHandler(conn *iscsiConnection) (err error
 		}
 		if task == nil {
 			err = fmt.Errorf("Cannot find iSCSI task with tag[%v]", conn.req.TaskTag)
-			glog.Error(err)
+			log.Error(err)
 			return
 		}
 		task.offset = task.offset + conn.req.DataLen
 		task.r2tCount = task.r2tCount - conn.req.DataLen
 		task.scmd.OutSDBBuffer.Buffer.Write(conn.req.RawData)
-		glog.V(2).Infof("Final: %v", conn.req.Final)
+		log.Debugf("Final: %v", conn.req.Final)
-		glog.V(2).Infof("r2tCount: %v", task.r2tCount)
+		log.Debugf("r2tCount: %v", task.r2tCount)
 		if !conn.req.Final {
-			glog.V(1).Infof("Not ready to exec the task")
+			log.Debugf("Not ready to exec the task")
 			conn.rxIOState = IOSTATE_RX_BHS
 			s.handler(DATAIN, conn)
 			return nil
@@ -697,7 +697,7 @@ func (s *ISCSITargetDriver) scsiCommandHandler(conn *iscsiConnection) (err error
 			break
 		}
 		task.offset = 0
-		glog.V(1).Infof("Process the Data-out package")
+		log.Debugf("Process the Data-out package")
 		conn.rxTask = task
 		if err = s.iscsiExecTask(task); err != nil {
 			return
@@ -730,11 +730,11 @@ func (s *ISCSITargetDriver) scsiCommandHandler(conn *iscsiConnection) (err error
 		iscsiExecLogout(conn)
 	case OpTextReq, OpSNACKReq:
 		err = fmt.Errorf("Cannot handle yet %s", opCodeMap[conn.req.OpCode])
-		glog.Error(err)
+		log.Error(err)
 		return
 	default:
 		err = fmt.Errorf("Unknown op %s", opCodeMap[conn.req.OpCode])
-		glog.Error(err)
+		log.Error(err)
 		return
 	}
 	conn.rxIOState = IOSTATE_RX_BHS
@@ -750,16 +750,16 @@ func (s *ISCSITargetDriver) iscsiTaskQueueHandler(task *iscsiTask) error {
 		return s.iscsiExecTask(task)
 	}
 	cmdsn := cmd.CmdSN
-	glog.V(2).Infof("CmdSN of command is %d, ExpCmdSN of session is %d", cmdsn, sess.ExpCmdSN)
+	log.Debugf("CmdSN of command is %d, ExpCmdSN of session is %d", cmdsn, sess.ExpCmdSN)
 	if cmdsn == sess.ExpCmdSN {
 	retry:
 		cmdsn += 1
 		sess.ExpCmdSN = cmdsn
-		glog.V(2).Infof("session's ExpCmdSN is %d", cmdsn)
+		log.Debugf("session's ExpCmdSN is %d", cmdsn)
 
-		glog.V(2).Infof("process task(%d)", task.cmd.CmdSN)
+		log.Debugf("process task(%d)", task.cmd.CmdSN)
 		if err := s.iscsiExecTask(task); err != nil {
-			glog.Error(err)
+			log.Error(err)
 		}
 		if len(sess.PendingTasks) == 0 {
 			return nil
@@ -775,10 +775,10 @@ func (s *ISCSITargetDriver) iscsiTaskQueueHandler(task *iscsiTask) error {
 	} else {
 		if cmd.CmdSN < sess.ExpCmdSN {
 			err := fmt.Errorf("unexpected cmd serial number: (%d, %d)", cmd.CmdSN, sess.ExpCmdSN)
-			glog.Error(err)
+			log.Error(err)
 			return err
 		}
-		glog.V(1).Infof("add task(%d) into task queue", task.cmd.CmdSN)
+		log.Debugf("add task(%d) into task queue", task.cmd.CmdSN)
 		// add this connection into queue and set this task as pending task
 		task.state = taskPending
 		sess.PendingTasks.Push(task)

pkg/scsi/backingstore.go

@@ -21,7 +21,7 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/golang/glog"
+	log "github.com/Sirupsen/logrus"
 	"github.com/gostor/gotgt/pkg/api"
 	"github.com/gostor/gotgt/pkg/util"
 )
@@ -133,12 +133,12 @@ write:
 		// hack: wbuf = []byte("hello world!")
 		err = bs.Write(wbuf, int64(offset))
 		if err != nil {
-			glog.Error(err)
+			log.Error(err)
 			key = MEDIUM_ERROR
 			asc = ASC_READ_ERROR
 			goto sense
 		}
-		glog.V(2).Infof("write data at %d for length %d", offset, len(wbuf))
+		log.Debugf("write data at %d for length %d", offset, len(wbuf))
 		var pg *api.ModePage
 		for _, p := range lu.ModePages {
 			if p.PageCode == 0x08 && p.SubPageCode == 0 {
@@ -181,11 +181,11 @@ verify:
 			bs.DataAdvise(int64(offset), int64(length), util.POSIX_FADV_WILLNEED)
 		}
 	}
-	glog.Infof("io done %s", string(scb))
+	log.Infof("io done %s", string(scb))
 	return nil
 sense:
 	if err != nil {
-		glog.Error(err)
+		log.Error(err)
 		return err
 	}
 

pkg/scsi/backingstore/common.go

@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/golang/glog"
+	log "github.com/Sirupsen/logrus"
 	"github.com/gostor/gotgt/pkg/api"
 	"github.com/gostor/gotgt/pkg/scsi"
 	"github.com/gostor/gotgt/pkg/util"
@@ -97,7 +97,7 @@ func (bs *FileBackingStore) Read(offset, tl int64) ([]byte, error) {
 func (bs *FileBackingStore) Write(wbuf []byte, offset int64) error {
 	length, err := bs.file.WriteAt(wbuf, offset)
 	if err != nil {
-		glog.Error(err)
+		log.Error(err)
 		return err
 	}
 	if length != len(wbuf) {

pkg/scsi/error.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2015 The GoStor Authors All rights reserved.
+Copyright 2016 The GoStor Authors All rights reserved.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

pkg/scsi/sbc.go

@@ -22,7 +22,7 @@ import (
 	"encoding/binary"
 	"unsafe"
 
-	"github.com/golang/glog"
+	log "github.com/Sirupsen/logrus"
 	"github.com/gostor/gotgt/pkg/api"
 	"github.com/gostor/gotgt/pkg/util"
 	"github.com/gostor/gotgt/pkg/version"
@@ -331,7 +331,7 @@ func SBCReadWrite(host int, cmd *api.SCSICommand) api.SAMStat {
 	if dev.Attrs.Removable && !dev.Attrs.Online {
 		key = NOT_READY
 		asc = ASC_MEDIUM_NOT_PRESENT
-		glog.Warningf("sense")
+		log.Warnf("sense")
 		goto sense
 	}
 
@@ -343,7 +343,7 @@ func SBCReadWrite(host int, cmd *api.SCSICommand) api.SAMStat {
 			if scb[1]&0xe0 != 0 {
 				key = ILLEGAL_REQUEST
 				asc = ASC_INVALID_FIELD_IN_CDB
-				glog.Warningf("sense")
+				log.Warnf("sense")
 				goto sense
 			}
 		*/
@@ -384,7 +384,7 @@ func SBCReadWrite(host int, cmd *api.SCSICommand) api.SAMStat {
 			api.PRE_FETCH_10, api.PRE_FETCH_16, api.COMPARE_AND_WRITE:
 			key = DATA_PROTECT
 			asc = ASC_WRITE_PROTECT
-			glog.Warningf("sense")
+			log.Warnf("sense")
 			goto sense
 		}
 	}
@@ -397,14 +397,14 @@ func SBCReadWrite(host int, cmd *api.SCSICommand) api.SAMStat {
 		if lba+uint64(tl) < lba || lba+uint64(tl) > dev.Size>>dev.BlockShift {
 			key = ILLEGAL_REQUEST
 			asc = ASC_LBA_OUT_OF_RANGE
-			glog.Warningf("sense: lba: %d, tl: %d, size: %d", lba, tl, dev.Size>>dev.BlockShift)
+			log.Warnf("sense: lba: %d, tl: %d, size: %d", lba, tl, dev.Size>>dev.BlockShift)
 			goto sense
 		}
 	} else {
 		if lba >= dev.Size>>dev.BlockShift {
 			key = ILLEGAL_REQUEST
 			asc = ASC_LBA_OUT_OF_RANGE
-			glog.Warningf("sense")
+			log.Warnf("sense")
 			goto sense
 		}
 	}
@@ -437,7 +437,7 @@ func SBCReadWrite(host int, cmd *api.SCSICommand) api.SAMStat {
 
 	err = bsPerformCommand(dev.Storage, cmd)
 	if err != nil {
-		glog.Error(err)
+		log.Error(err)
 		key = HARDWARE_ERROR
 		asc = ASC_INTERNAL_TGT_FAILURE
 	} else {
@@ -563,14 +563,14 @@ func SBCVerify(host int, cmd *api.SCSICommand) api.SAMStat {
 		if lba+uint64(tl) < lba || lba+uint64(tl) > dev.Size>>dev.BlockShift {
 			key = ILLEGAL_REQUEST
 			asc = ASC_LBA_OUT_OF_RANGE
-			glog.Warningf("sense: lba: %d, tl: %d, size: %d", lba, tl, dev.Size>>dev.BlockShift)
+			log.Warnf("sense: lba: %d, tl: %d, size: %d", lba, tl, dev.Size>>dev.BlockShift)
 			goto sense
 		}
 	} else {
 		if lba >= dev.Size>>dev.BlockShift {
 			key = ILLEGAL_REQUEST
 			asc = ASC_LBA_OUT_OF_RANGE
-			glog.Warningf("sense")
+			log.Warnf("sense")
 			goto sense
 		}
 	}
@@ -579,7 +579,7 @@ func SBCVerify(host int, cmd *api.SCSICommand) api.SAMStat {
 	cmd.TL = tl << dev.BlockShift
 	err = bsPerformCommand(dev.Storage, cmd)
 	if err != nil {
-		glog.Error(err)
+		log.Error(err)
 		key = HARDWARE_ERROR
 		asc = ASC_INTERNAL_TGT_FAILURE
 	} else {

pkg/scsi/scsi.go

@@ -23,7 +23,7 @@ import (
 	"sync"
 	"unsafe"
 
-	"github.com/golang/glog"
+	log "github.com/Sirupsen/logrus"
 	"github.com/gostor/gotgt/pkg/api"
 	"github.com/satori/go.uuid"
 )
@@ -80,21 +80,21 @@ func (s *SCSITargetService) AddCommandQueue(tid int, scmd *api.SCSICommand) erro
 	lun := *(*uint64)(unsafe.Pointer(&scmd.Lun))
 	scmd.Device = target.Devices[lun]
 
-	glog.V(2).Infof("scsi opcode: 0x%x, LUN: %d", int(scmd.SCB.Bytes()[0]), binary.LittleEndian.Uint64(scmd.Lun[:]))
+	log.Debugf("scsi opcode: 0x%x, LUN: %d", int(scmd.SCB.Bytes()[0]), binary.LittleEndian.Uint64(scmd.Lun[:]))
 
 	if scmd.Device == nil {
 		scmd.Device = target.LUN0
 		if lun != 0 {
 			BuildSenseData(scmd, ILLEGAL_REQUEST, ASC_INVALID_FIELD_IN_CDB)
 			scmd.Result = api.SAMStatCheckCondition.Stat
-			glog.Warningf("%v", api.SAMStatCheckCondition.Err)
+			log.Warnf("%v", api.SAMStatCheckCondition.Err)
 			return nil
 		}
 	}
 	result := scmd.Device.PerformCommand(tid, scmd)
 	if result != api.SAMStatGood {
 		scmd.Result = result.Stat
-		glog.Warningf("%v", result.Err)
+		log.Warnf("%v", result.Err)
 	}
 	return nil
 }
@@ -162,7 +162,7 @@ func BuildSenseData(cmd *api.SCSICommand, key byte, asc SCSISubError) {
 			senseBuffer.Truncate(int(inBufLen))
 		}
 	} else {
-		glog.V(2).Infof("cannot calc cbd alloc length. truncate failed")
+		log.Debugf("cannot calc cbd alloc length. truncate failed")
 	}
 	cmd.Result = key
 	cmd.SenseBuffer = senseBuffer

pkg/scsi/scsilumap.go

@@ -17,7 +17,7 @@ limitations under the License.
 package scsi
 
 import (
-	"errors"
+	"fmt"
 	"strconv"
 	"sync"
 
@@ -75,7 +75,7 @@ func InitSCSILUMap(config *config.Config) error {
 	for _, bs := range config.Storages {
 		lu, err := NewSCSILu(bs.DeviceID, bs.Path, bs.Online)
 		if err != nil {
-			return errors.New("Init SCSI LU map error.")
+			return fmt.Errorf("Init SCSI LU map error: %v", err)
 		}
 		globalSCSILUMap.AllDevices[bs.DeviceID] = lu
 	}
@@ -84,7 +84,7 @@ func InitSCSILUMap(config *config.Config) error {
 		for lunstr, deviceID := range tgt.LUNs {
 			lun, err := strconv.ParseUint(lunstr, 10, 64)
 			if err != nil {
-				return errors.New("LU Number must be a number")
+				return fmt.Errorf("LU Number must be a number")
 			}
 			mappingLUN(deviceID, lun, tgtName)
 			// Init SCSISimpleReservationOperator

pkg/scsi/spc.go

@@ -22,7 +22,7 @@ import (
 	"encoding/binary"
 	"fmt"
 
-	"github.com/golang/glog"
+	log "github.com/Sirupsen/logrus"
 	"github.com/gostor/gotgt/pkg/api"
 	"github.com/gostor/gotgt/pkg/util"
 	"github.com/satori/go.uuid"
@@ -341,7 +341,7 @@ func SPCReportLuns(host int, cmd *api.SCSICommand) api.SAMStat {
 	// Get Allocation Length
 	allocationLength = util.GetUnalignedUint32(scb.Bytes()[6:10])
 	if allocationLength < 16 {
-		glog.Warningf("goto sense, allocationLength < 16")
+		log.Warn("goto sense, allocationLength < 16")
 		goto sense
 	}
 
@@ -577,24 +577,24 @@ func SPCReportSupportedOperationCodes(host int, cmd *api.SCSICommand) api.SAMSta
 	rsa := util.GetUnalignedUint16(scb[4:])
 	switch reporting_options {
 	case 0x00: /* report all */
-		glog.V(3).Infof("Service Action: report all")
+		log.Debugf("Service Action: report all")
 		err := reportOpcodesAll(cmd, rctd)
 		if err != nil {
-			glog.Error(err)
+			log.Error(err)
 			goto sense
 		}
 	case 0x01: /* report one no service action*/
-		glog.V(3).Infof("Service Action: report one no service action")
+		log.Debugf("Service Action: report one no service action")
 		err := reportOpcodeOne(cmd, rctd, opcode, rsa, false)
 		if err != nil {
-			glog.Error(err)
+			log.Error(err)
 			goto sense
 		}
 	case 0x02: /* report one service action */
-		glog.V(3).Infof("Service Action: report one service action")
+		log.Debugf("Service Action: report one service action")
 		err := reportOpcodeOne(cmd, rctd, opcode, rsa, true)
 		if err != nil {
-			glog.Error(err)
+			log.Error(err)
 			goto sense
 		}
 	default:

pkg/scsi/target.go

@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"unsafe"
 
-	"github.com/golang/glog"
+	log "github.com/Sirupsen/logrus"
 	"github.com/gostor/gotgt/pkg/api"
 	"github.com/satori/go.uuid"
 )
@@ -97,12 +97,12 @@ func deviceReserve(cmd *api.SCSICommand) error {
 		}
 	}
 	if lu == nil {
-		glog.Errorf("invalid target and lun %d %s", cmd.Target.TID, lun)
+		log.Errorf("invalid target and lun %d %s", cmd.Target.TID, lun)
 		return nil
 	}
 
 	if !uuid.Equal(lu.ReserveID, uuid.Nil) && uuid.Equal(lu.ReserveID, cmd.ITNexusID) {
-		glog.Errorf("already reserved %d, %d", lu.ReserveID, cmd.ITNexusID)
+		log.Errorf("already reserved %d, %d", lu.ReserveID, cmd.ITNexusID)
 		return fmt.Errorf("already reserved")
 	}
 	lu.ReserveID = cmd.ITNexusID