func main() {
getopt.ListVarLong(&configPaths, "config", 'c',
"REQUIRED: Path to configuration file (can be used multiple times)", "PATH")
getopt.BoolVarLong(&verbose, "verbose", 'v', "Verbose progress indicators and messages")
help := getopt.BoolLong("help", 'h', "Show this help message and exit")
getopt.SetParameters("")
getopt.Parse()
if *help {
getopt.Usage()
os.Exit(0)
}
if len(configPaths) == 0 {
log.Printf("no configuration (-c/--config) found")
getopt.Usage()
os.Exit(1)
}
log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)
// set parallelism (automatic in Go 1.6+)
if runtime.GOMAXPROCS(0) < runtime.NumCPU() {
runtime.GOMAXPROCS(runtime.NumCPU())
log.Printf("setting GOMAXPROCS = NumCPU = %d\n", runtime.NumCPU())
}
for _, configPath := range configPaths {
cfg, err := config.NewConfiguration(configPath)
if err != nil {
log.Fatal(err)
continue
}
idx, err := index.NewIndex(cfg)
if err != nil {
log.Print(err)
return
}
if err := idx.Update(); err != nil {
log.Print(err)
return
}
if err := idx.WriteOut(); err != nil {
log.Print(err)
return
}
}
}
func main() {
getopt.SetParameters("<root dir> <bucket name>")
getopt.Parse()
if *help {
getopt.PrintUsage(os.Stdout)
return
}
args := getopt.Args()
if len(args) != 2 {
getopt.PrintUsage(os.Stderr)
os.Exit(1)
}
rootDir := args[0]
bucketName := args[1]
resourcesMap := map[string]interface{}{}
result := map[string]interface{}{
"resource": map[string]interface{}{
"aws_s3_bucket_object": resourcesMap,
},
}
filepath.Walk(rootDir, func(path string, info os.FileInfo, err error) error {
if err != nil {
fmt.Fprintf(os.Stderr, "Error reading %s: %s\n", path, err)
// Skip stuff we can't read.
return nil
}
relPath, err := filepath.Rel(rootDir, path)
if err != nil {
fmt.Fprintf(os.Stderr, "Failed make %s relative: %s\n", path, err)
return nil
}
path, err = filepath.EvalSymlinks(path)
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to resolve symlink %s: %s\n", path, err)
return nil
}
if info.IsDir() {
// Don't need to create directories since they are implied
// by the files within.
return nil
}
for _, pattern := range *exclude {
var toMatch []string
if strings.ContainsRune(pattern, filepath.Separator) {
toMatch = append(toMatch, relPath)
} else {
// If the pattern does not include a path separator
// then we apply it to all segments of the path
// individually.
toMatch = strings.Split(relPath, string(filepath.Separator))
}
for _, matchPath := range toMatch {
matched, _ := filepath.Match(pattern, matchPath)
if matched {
return nil
}
}
}
// We use the initial bytes of the file to infer a MIME type
file, err := os.Open(path)
if err != nil {
fmt.Fprintf(os.Stderr, "Error opening %s: %s\n", path, err)
return nil
}
hasher := sha1.New()
fileBytes := make([]byte, 1024*1024)
contentType := ""
_, err = file.Read(fileBytes)
// If we got back and error and it isn't the end of file then
// skip it. This does "something" with 0 length files. It is
// likely we should really be categorizing those based on file
// extension.
if err != nil && err != io.EOF {
fmt.Fprintf(os.Stderr, "Error reading %s: %s\n", path, err)
return nil
}
if strings.HasSuffix(relPath, ".svg") {
// If we start to need a set of overrides for DetectContentType
// then we need to find a different way to do this.
contentType = "image/svg+xml"
} else {
contentType = http.DetectContentType(fileBytes)
}
// Resource name is a hash of the path, so it should stay consistent
// for a given file path as long as the relative path to the target
// directory is always the same across runs.
hasher.Write([]byte(relPath))
resourceName := fmt.Sprintf("%x", hasher.Sum(nil))
resourcesMap[resourceName] = map[string]interface{}{
"bucket": bucketName,
"key": relPath,
"source": path,
"etag": fmt.Sprintf("${md5(file(%q))}", path),
"content_type": contentType,
}
return nil
})
encoder := json.NewEncoder(os.Stdout)
encoder.Encode(result)
}
func main() {
// Uncomment the following lines if you need to time the options parsing
//log.SetFlags(log.Ldate | log.Ltime | log.Lmicroseconds)
//log.Println(": Program started")
// Configure Command Line Options
var useUDP, quiet, debug bool
var maxRTT time.Duration
var numPing int
getopt.BoolVarLong(&useUDP, "udp", 'u', "use UDP instead of ICMP")
getopt.BoolVarLong(&quiet, "quiet", 'q', "only display host data")
getopt.BoolVarLong(&debug, "debug", 'v', "print additional messages")
maxRTT = defaultMaxRTT
getopt.DurationVarLong(&maxRTT, "rtt", 't', "max RTT for each ping")
numPing = defaultPingCount
getopt.IntVarLong(&numPing, "count", 'n', "max number of pings per target")
getopt.SetParameters("startIP endIP")
getopt.Parse()
// Verify arguments
if getopt.NArgs() != 2 {
log.Println("Incorrect number of arguments!")
getopt.PrintUsage(os.Stderr)
os.Exit(1)
}
startIPString := getopt.Arg(0)
endIPString := getopt.Arg(1)
// Test for incompatible options
if quiet && debug {
log.Println("`quiet` and `debug` are incompatible")
getopt.PrintUsage(os.Stderr)
os.Exit(1)
}
if debug {
log.SetFlags(log.Ldate | log.Ltime | log.Lmicroseconds)
log.Println(": Command Line Parsing complete")
}
// Convert to IP object
startIP := net.ParseIP(startIPString)
if startIP == nil {
log.Fatal("Start IP,", startIPString, ", is not a valid IP address")
}
if debug {
log.Println(": Start IP\t", startIPString)
}
endIP := net.ParseIP(endIPString)
if endIP == nil {
log.Fatal("End IP,", endIPString, ", is not a valid IP address")
}
if debug {
log.Println(": End IP \t", endIPString)
}
netProto := "ip4:icmp"
if strings.Index(startIPString, ":") != -1 {
netProto = "ip6:ipv6-icmp"
}
p := fastping.NewPinger()
p.MaxRTT = maxRTT
p.OnRecv = func(addr *net.IPAddr, rtt time.Duration) {
var device resultData
device.PingResult = addr.String() + "\t" + roundDuration(baseRTT+rtt, time.Millisecond).String()
ips = append(ips, device)
p.RemoveIPAddr(addr)
}
currentIP := make(net.IP, len(startIP))
for copy(currentIP, startIP); bytes.Compare(currentIP, endIP) <= 0; inc(currentIP) {
ra, err := net.ResolveIPAddr(netProto, currentIP.String())
if err != nil {
log.Fatal(err)
}
p.AddIPAddr(ra)
}
if useUDP {
p.Network("udp")
}
if debug {
log.Println(": Start Scan")
}
for index := 0; index < numPing; index++ {
baseRTT = time.Duration(index) * maxRTT
err := p.Run()
if err != nil {
log.Fatal("Pinger returns error: ", err)
}
}
if debug {
log.Println(": Scan complete")
}
if !quiet {
fmt.Println()
fmt.Printf("%d devices found\n", len(ips))
fmt.Println()
}
if debug {
log.Println(": Start Host Lookup")
}
// Query DNS for the name of each device found by the ping scan
var ipAndTime []string
var hostname string
var wg sync.WaitGroup
for index, ip := range ips {
ipAndTime = strings.SplitN(ip.PingResult, "\t", 2)
wg.Add(1)
go func(ipString string, localIndex int) {
hosts, err := net.LookupAddr(ipString)
if err != nil {
hostname = "Error: " + err.Error()
} else {
hostname = strings.Join(hosts, ", ")
}
ips[localIndex].HostResult = hostname
wg.Done()
}(ipAndTime[0], index)
}
wg.Wait()
if debug {
log.Println(": DNS complete")
}
sort.Sort(byIP(ips))
if debug {
log.Println(": Sort complete")
}
for _, ip := range ips {
fmt.Printf("%-25s\t--> %s\n", ip.PingResult, ip.HostResult)
}
if !quiet {
fmt.Println()
}
if debug {
log.Println(": Program complete")
}
}
func main() {
getopt.SetParameters("<root dir> <bucket name>")
getopt.Parse()
if *help {
getopt.PrintUsage(os.Stdout)
return
}
args := getopt.Args()
if len(args) != 2 {
getopt.PrintUsage(os.Stderr)
os.Exit(1)
}
rootDir := args[0]
bucketName := args[1]
resourcesMap := map[string]interface{}{}
result := map[string]interface{}{
"resource": map[string]interface{}{
"aws_s3_bucket_object": resourcesMap,
},
}
filepath.Walk(rootDir, func(path string, info os.FileInfo, err error) error {
if err != nil {
fmt.Fprintf(os.Stderr, "Error reading %s: %s\n", path, err)
// Skip stuff we can't read.
return nil
}
relPath, err := filepath.Rel(rootDir, path)
if err != nil {
fmt.Fprintf(os.Stderr, "Failed make %s relative: %s\n", path, err)
return nil
}
path, err = filepath.EvalSymlinks(path)
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to resolve symlink %s: %s\n", path, err)
return nil
}
if info.IsDir() {
// Don't need to create directories since they are implied
// by the files within.
return nil
}
for _, pattern := range *exclude {
var toMatch []string
if strings.ContainsRune(pattern, filepath.Separator) {
toMatch = append(toMatch, relPath)
} else {
// If the pattern does not include a path separator
// then we apply it to all segments of the path
// individually.
toMatch = strings.Split(relPath, string(filepath.Separator))
}
for _, matchPath := range toMatch {
matched, _ := filepath.Match(pattern, matchPath)
if matched {
return nil
}
}
}
resourceNameBytes := sha1.Sum([]byte(relPath))
resourceName := fmt.Sprintf("%x", resourceNameBytes)
resourcesMap[resourceName] = map[string]interface{}{
"bucket": bucketName,
"key": relPath,
"source": path,
}
return nil
})
encoder := json.NewEncoder(os.Stdout)
encoder.Encode(result)
}