package main

import (
  "github.com/mitchellh/goamz/aws"
  "github.com/mitchellh/goamz/s3"
  "log"
  "fmt"
)

func main() {
  auth, err := aws.EnvAuth()
  if err != nil {
    log.Fatal(err)
  }
  client := s3.New(auth, aws.USEast)
  resp, err := client.ListBuckets()

  if err != nil {
    log.Fatal(err)
  }

  log.Print(fmt.Sprintf("%T %+v", resp.Buckets[0], resp.Buckets[0]))
}

package main

import (
	"fmt"
	"github.com/mitchellh/goamz/aws"
	"github.com/mitchellh/goamz/s3"
	"log"
)

func main() {
	auth, err := aws.EnvAuth()
	if err != nil {
		log.Fatal(err)
	}

	var cnc = aws.Region{
		"cnc", // Name
		"",    // EC2Endpoint
		"http://s3.bj.xs3cnc.com", // S3Endpoint
		"",    // S3BucketEndpoint
		false, // S3LocationConstraint
		false, // S3LowercaseBucket
		"",    // SDBEndpoint
		"",    // SNSEndpoint
		"",    // SQSEndpoint
		"",    // IAMEndpoint
		"",    // ELBEndpoint
		"",    // AutoScalingEndpoint
		"",    // RdsEndpoint
		"",    // Route53Endpoint
	}
	client := s3.New(auth, cnc)
	resp, err := client.ListBuckets()
	if err != nil {
		log.Fatal(err)
	}

	for _, b := range resp.Buckets {
		fmt.Printf("Bucket Name: %s\n", b.Name)
		bc, err := b.GetBucketContents()
		if err == nil {
			for _, key := range *bc {
				fmt.Printf("\t%s, %s, %d, %s, %s, %s\n",
					key.Key, key.LastModified, key.Size, key.StorageClass,
					key.Owner.ID, key.Owner.DisplayName)
			}
		}
	}
}

package main

import (
	"fmt"
	"io"
	"net"
	"os"
	"time"
)

const BUFFER_SIZE = 1024 * 4

var buffer = make([]byte, BUFFER_SIZE)

func handleConnect(tcpConn *net.TCPConn) {
	if tcpConn == nil {
		return
	}
	for {
		n, err := tcpConn.Read(buffer)
		if err == io.EOF {
			fmt.Printf("The RemoteAddr: %s is closed!\n", tcpConn.RemoteAddr().String())
			return
		}
		handleError(err)
		if n > 0 {
			//fmt.Printf("Read: %s", string(buffer[:n]))
			str := tcpConn.RemoteAddr().String() + " @ " +
				time.Now().Format("2006-01-02 15:04:05 Z07:00") + "\r\n" +
				string(buffer[:n])
			tcpConn.Write([]byte(str))
			fmt.Printf("Echo: %s", str)
		}
	}
}

// 错误处理
func handleError(err error) {
	if err == nil {
		return
	}
	panic(err)
	//fmt.Printf("error: %s\n", err.Error())
}

func main() {
	if len(os.Args) < 2 {
		fmt.Println("Usage:", os.Args[0], "<port>")
		return
	}
	port := os.Args[1]
	tcpAddr, err := net.ResolveTCPAddr("tcp4", "0.0.0.0:"+port)
	handleError(err)
	tcpListener, err := net.ListenTCP("tcp4", tcpAddr)
	handleError(err)
	defer tcpListener.Close()

	fmt.Println("Listening on", tcpAddr, "...")
	for {
		tcpConn, err := tcpListener.AcceptTCP()
		fmt.Printf("The client: %s has connected!\n", tcpConn.RemoteAddr().String())
		handleError(err)
		defer tcpConn.Close()
		go handleConnect(tcpConn)
	}
}

// UMU @ 2015-08-17 11:30
// Last update: 2015-08-21 17:40
package main

import (
	"bufio"
	"fmt"
	"os"
	"path"
	"path/filepath"
	"time"
)

func isSourceFile(ext string) bool {
	var kSourceFileExts = []string{".c", ".cc", ".cpp", ".h", ".hpp",
		".go",
		".java"}
	for _, r := range kSourceFileExts {
		if r == ext {
			return true
		}
	}
	return false
}

func main() {
	if len(os.Args) < 2 {
		fmt.Println("Usage: ", os.Args[0], "[file or folder]...")
		return
	}

	start := time.Now()
	files := make(map[string]struct{})
	lines := 0

	for _, r := range os.Args {
		fi, err := os.Stat(r)
		if err == nil || os.IsExist(err) {
			if fi.IsDir() {
				AddDirectory(r, files)
			} else {
				AddFile(r, files)
			}
		}
	}

	for file, _ := range files {
		l := CountLine(file)
		lines += l
		fmt.Println(file, l)
	}
	fmt.Printf("Total lines: %d, cost %fs\n", lines, timeElapsed(start))
}

func AddDirectory(name string, files map[string]struct{}) {
	filepath.Walk(name, func(path string, fi os.FileInfo, err error) error {
		if nil == fi {
			return err
		}
		if fi.IsDir() {
			return nil
		}
		AddFile(path, files)
		return nil
	})
}

func AddFile(name string, files map[string]struct{}) {
	ext := path.Ext(name)
	if isSourceFile(ext) {
		path, err := filepath.Abs(name)
		if err == nil {
			_, exists := files[path]
			if exists {
				fmt.Println("Duplicated", path)
			} else {
				files[path] = struct{}{}
				fmt.Println("Add", path)
			}
		}
	}
}

func CountLine(path string) (num int) {
	f, err := os.Open(path)
	if nil != err {
		return
	}
	defer f.Close()

	s := bufio.NewScanner(f)
	for s.Scan() {
		num += 1
	}
	return
}

func timeElapsed(start time.Time) float64 {
	dis := time.Since(start).Seconds()
	return dis
}