func (m Memory) Generate() ([]i3.Output, error) {
	mem, err := mem.VirtualMemory()
	if err != nil {
		return nil, err
	}

	total := mem.Total
	used := total - mem.Buffers - mem.Cached - mem.Free

	percUsed := (100 * used) / total

	var color string
	switch {
	case m.IsCrit(int(percUsed)):
		color = i3.DefaultColors.Crit
	case m.IsWarn(int(percUsed)):
		color = i3.DefaultColors.Warn
	default:
		color = i3.DefaultColors.OK
	}

	out := make([]i3.Output, 1)
	out[0] = i3.Output{
		Name:      m.Name,
		FullText:  fmt.Sprintf(FormatString, percUsed, bytefmt.ByteSize(used), bytefmt.ByteSize(total)),
		Color:     color,
		Separator: true,
	}

	return out, nil
}

func (t *TerminalUI) AdjustMemory(stats Statistics) {
	// memory gauges
	mem := make([]*ui.Gauge, len(stats.Instances))
	for i, idx := range stats.Instances {
		// show max 8 instances
		if i > 7 {
			break
		}

		memory := uint64(stats.Data[idx].Stats.Usage.Memory)
		quota := uint64(stats.Data[idx].Stats.MemoryQuota)
		percent := int(math.Ceil((float64(memory) / float64(quota)) * 100.0))
		mem[i] = ui.NewGauge()
		mem[i].Percent = percent
		mem[i].Height = 13 - min(len(stats.Instances), 8)
		mem[i].Border.Label = fmt.Sprintf("Memory - Instance %d: %d%% (%s / %s)",
			i, percent, bytefmt.ByteSize(memory), bytefmt.ByteSize(quota))
		mem[i].Border.FgColor = ui.ColorWhite
		mem[i].Border.LabelFgColor = ui.ColorWhite
		mem[i].BarColor = colors[i%6]
		mem[i].PercentColor = ui.ColorWhite
	}
	t.Memory = mem

	// update layout
	ui.Body.Rows = []*ui.Row{
		ui.NewRow(
			ui.NewCol(3, 0, t.Usage),
			ui.NewCol(3, 0, t.Summary),
			ui.NewCol(6, 0, t.Disk)),
		ui.NewRow(
			ui.NewCol(6, 0, t.CPU),
			t.newMemCol(6, 0, t.Memory)),
	}
}

func DiskUsage(path string) (disk DiskStatus) {
	fs := syscall.Statfs_t{}
	err := syscall.Statfs(path, &fs)
	if err != nil {
		return
	}
	fmt.Print("",
		"Type:", fs.Type, "\n", /* Type of filesystem (see below) */
		"Bsize:", fs.Bsize, "\n", /* Optimal transfer block size */
		"Blocks:", fs.Blocks, "\n", /* Total data blocks in filesystem */
		"Bfree:", fs.Bfree, "\n", /* Free blocks in filesystem */
		"Bavail:", fs.Bavail, "\n", /* Free blocks available to unprivileged user*/
		"Files:", fs.Files, "\n", /* Total file nodes in filesystem */
		"Ffree:", fs.Ffree, "\n", /* Free file nodes in filesystem */
		//"Fsid:", fs.Bsize, "\n",/* Filesystem ID */
		"Namelen:", fs.Namelen, "\n", /* Maximum length of filenames */
		"Frsize:", fs.Frsize, "\n", /* Fragment size (since Linux 2.6) */
		"Flags:", fs.Flags, "\n", /* Mount flags of filesystem (since Linux 2.6.36) */
		//"Spare:", fs.Bsize, "\n", /* Padding bytes reserved for future use */
	)

	disk.All = fs.Blocks * uint64(fs.Bsize)
	disk.Free = fs.Bfree * uint64(fs.Bsize)
	disk.Used = disk.All - disk.Free
	fmt.Println("",
		"Total:", disk.All, bytefmt.ByteSize(disk.All), "\n",
		"Used:", disk.Used, bytefmt.ByteSize(disk.Used), "\n",
		"Free:", disk.Free, bytefmt.ByteSize(disk.Free))
	return
}

func (t *TerminalUI) AdjustSummary(stats Statistics) {
	var uptime int64
	var cpuUsage float64
	var memUsage, memQuota, diskUsage, diskQuota int64
	for _, idx := range stats.Instances {
		uptime = max(uptime, stats.Data[idx].Stats.Uptime)
		cpuUsage += stats.Data[idx].Stats.Usage.CPU
		memUsage += stats.Data[idx].Stats.Usage.Memory
		diskUsage += stats.Data[idx].Stats.Usage.Disk
		memQuota += stats.Data[idx].Stats.MemoryQuota
		diskQuota += stats.Data[idx].Stats.DiskQuota
	}
	up, _ := time.ParseDuration(fmt.Sprintf("%ds", uptime))

	summaryText := fmt.Sprintf(
		`Instances running: %d

Uptime: %s
Up Since: %s

Total CPU Usage: %.4f%%
Total Memory Usage: %s / %s
Total Disk Usage: %s / %s`,
		len(stats.Instances),
		up.String(),
		time.Now().Add(-1*up).Format("Mon, 02 Jan 2006 15:04 MST"),
		cpuUsage*100.0,
		bytefmt.ByteSize(uint64(memUsage)), bytefmt.ByteSize(uint64(memQuota)),
		bytefmt.ByteSize(uint64(diskUsage)), bytefmt.ByteSize(uint64(diskQuota)))
	t.Summary.Text = summaryText
}

//Initalisiert Dynamischen Pc
func (y *PCDynamic) PCInitDynamic(s *SSH) error {
	/*
		Id int						`id`

		MemFree string				`memfree`
		MemAvailable string			`memavail`
		MemUsed uint64				`memused`
		MemUsedProzent float64		`memusedprozent`

		LoadAvg float64				`loadavg`
		NumProcess uint64			`numprocess`
	*/
	loadavg := &linuxproc.LoadAvg{}
	meminfo := &linuxproc.MemInfo{}
	err := errors.New("")

	if s.Client == nil {
		err := errors.New("Could not find a ssh Client ")
		revel.ERROR.Print(err)
		return err
	} else {
		s.Download("/proc/loadavg", tempDir+"/loadavg"+strconv.Itoa(y.Id))
		loadavg, err = linuxproc.ReadLoadAvg("/proc/loadavg")
		if err != nil {
			revel.ERROR.Print(err)
			return err
		}

		y.LoadAvg = loadavg.Last1Min
		y.NumProcess = loadavg.ProcessRunning

		s.Download("/proc/meminfo", tempDir+"/meminfo"+strconv.Itoa(y.Id))
		meminfo, err = linuxproc.ReadMemInfo("/home/pr0gramming/Dokumente/meminfo" + strconv.Itoa(y.Id))
		if err != nil {
			revel.ERROR.Print(err)
			return err
		}

	}

	y.MemUsed = bytefmt.ByteSize((meminfo.MemTotal - meminfo.MemFree) * 1024)
	y.MemFree = bytefmt.ByteSize(meminfo.MemFree * 1024)
	y.MemAvailable = bytefmt.ByteSize(meminfo.MemAvailable * 1024)

	a := float64(meminfo.MemTotal)
	b := float64(meminfo.MemFree)
	y.MemUsedProzent = strconv.FormatFloat(float64(((a-b)/a)*100), 'f', -1, 64)

	//println("test: " + (y.MemUsedProzent))
	return nil
}

func (me *CoreService) Status() *Sac {

	out := NewSac()

	m := runtime.MemStats{}
	runtime.ReadMemStats(&m)

	mem := NewSac()

	mem_gen := NewSac().
		Set("alloc", bytefmt.ByteSize(m.Alloc)).
		Set("total_alloc", bytefmt.ByteSize(m.TotalAlloc))
	mem.Set("general", mem_gen)

	mem_hp := NewSac().
		Set("alloc", bytefmt.ByteSize(m.HeapAlloc)).
		Set("sys", bytefmt.ByteSize(m.HeapAlloc)).
		Set("idle", bytefmt.ByteSize(m.HeapIdle)).
		Set("inuse", bytefmt.ByteSize(m.HeapInuse)).
		Set("released", bytefmt.ByteSize(m.HeapReleased)).
		Set("objects", bytefmt.ByteSize(m.HeapObjects))
	mem.Set("heap", mem_hp)

	out.Set("mem", mem).
		Set("server-time", time.Now().Format("2006-01-02 15:04:05 MST")).
		Set("go-version", runtime.Version()[2:]).
		Set("aqua-version", release)

	return out
}

func (g DiskUsageGenerator) Generate() ([]i3.Output, error) {
	items := make([]i3.Output, len(g.Items))

	for i, item := range g.Items {
		usage, err := getUsage(item.Path)
		if err != nil {
			return nil, err
		}

		free := bytefmt.ByteSize(usage.Free * bytefmt.BYTE)

		items[i].FullText = fmt.Sprintf(freeFormat, item.Name, free)

		freePercent := 100 - int(usage.UsedPerc)

		var color string
		switch {
		case freePercent < g.CritThreshold:
			color = i3.DefaultColors.Crit
		case freePercent < g.WarnThreshold:
			color = i3.DefaultColors.Warn
		default:
			color = i3.DefaultColors.OK
		}

		items[i].Color = color

		items[i].Name = g.Name
		items[i].Instance = item.Path
	}

	items[len(items)-1].Separator = true

	return items, nil
}

func (factory *DropletRunnerCommandFactory) listDroplets(context *cli.Context) {
	if !factory.ensureBlobStoreVerified() {
		return
	}

	droplets, err := factory.dropletRunner.ListDroplets()
	if err != nil {
		factory.UI.SayLine(fmt.Sprintf("Error listing droplets: %s", err))
		factory.ExitHandler.Exit(exit_codes.CommandFailed)
		return
	}

	sort.Sort(dropletSliceSortedByCreated(droplets))

	w := &tabwriter.Writer{}
	w.Init(factory.UI, 12, 8, 1, '\t', 0)

	fmt.Fprintln(w, "Droplet\tCreated At\tSize")
	for _, droplet := range droplets {
		size := bytefmt.ByteSize(uint64(droplet.Size))
		if !droplet.Created.IsZero() {
			fmt.Fprintf(w, "%s\t%s\t%s\n", droplet.Name, droplet.Created.Format("01/02 15:04:05.00"), size)
		} else {
			fmt.Fprintf(w, "%s\t\t%s\n", droplet.Name, size)
		}
	}

	w.Flush()
}

func (runner *Runner) downloadBuildpacks() error {
	// Do we have a custom buildpack?
	for _, buildpackName := range runner.config.BuildpackOrder() {
		buildpackUrl, err := url.Parse(buildpackName)
		if err != nil {
			return fmt.Errorf("Invalid buildpack url (%s): %s", buildpackName, err.Error())
		}
		if !buildpackUrl.IsAbs() {
			continue
		}

		destination := runner.config.BuildpackPath(buildpackName)

		if IsZipFile(buildpackUrl.Path) {
			var size uint64
			zipDownloader := NewZipDownloader(runner.config.SkipCertVerify())
			size, err = zipDownloader.DownloadAndExtract(buildpackUrl, destination)
			if err == nil {
				fmt.Printf("Downloaded buildpack `%s` (%s)", buildpackUrl.String(), bytefmt.ByteSize(size))
			}
		} else {
			err = GitClone(*buildpackUrl, destination)
		}
		if err != nil {
			return err
		}
	}

	return nil
}

func main() {
	flag.Parse()
	log.Print("scanning")
	start := time.Now()
	frontend := hath.NewFrontend(dir)
	files := make(chan hath.File)
	progress := make(chan hath.Progress)
	wg := new(sync.WaitGroup)
	wg.Add(1)
	go func() {
		for p := range progress {
			log.Println("scan progress", p)
		}
	}()
	go func() {
		defer close(files)
		defer wg.Done()
		if err := frontend.Scan(files, progress); err != nil {
			log.Println("error while scanning:", err)
		} else {
			log.Println("scanned")
		}
	}()
	w := new(walker)
	for f := range files {
		// fmt.Print(".")
		w.count++
		w.sum += f.Size
	}
	wg.Wait()
	log.Println("end")
	end := time.Now()
	duration := end.Sub(start)
	log.Println("count", w.count, "size", bytefmt.ByteSize(uint64(w.sum)), "duration", duration)
}

func Fetch(url string) (*ServerInfo, error) {
	if url == "" {
		return nil, fmt.Errorf("Error fetching server info: url can not be empty.")
	}
	resp, err := http.Get(url)
	if err != nil {
		return nil, err
	}
	v := &struct {
		MemStats runtime.MemStats `"json":"memstats"`
	}{}
	if err := json.NewDecoder(resp.Body).Decode(v); err != nil {
		log.Fatalln(err.Error())
	}

	p := time.Duration(v.MemStats.PauseTotalNs) * time.Nanosecond
	return &ServerInfo{
		GC: GC{
			CPUFraction:   v.MemStats.GCCPUFraction,
			Num:           v.MemStats.NumGC,
			PauseTotal:    p,
			PauseTotalStr: p.String(),
			Enabled:       v.MemStats.EnableGC,
			Debug:         v.MemStats.DebugGC,
		},
		Mem: Mem{
			TotalAlloc:    v.MemStats.TotalAlloc,
			TotalAllocStr: bytefmt.ByteSize(v.MemStats.TotalAlloc),
		},
	}, nil
}

func main() {

	argsWithoutProg := os.Args[1:]

	if len(argsWithoutProg) == 0 {
		fmt.Println("Usage: go run sum.go filter")
		return
	}
	filter := strings.Join(argsWithoutProg, " ")

	file, err := os.Open("diff.txt")
	check(err)
	defer file.Close()

	var added, removed uint64

	re, err := regexp.Compile(`(.+)\:`)

	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		line := scanner.Text()
		if len(line) > 3 && strings.Contains(line[3:], filter) {
			if line[0:3] == "Inc" || line[0:3] == "New" {
				res := re.FindStringSubmatch(line[4:])
				if len(res) > 0 {
					added += SizeInBytes(res[1])
				}
			} else if line[0:3] == "Dec" || line[0:3] == "Rem" {
				res := re.FindStringSubmatch(line[4:])
				if len(res) > 0 {
					removed += SizeInBytes(res[1])
				}
			}

		}
	}

	color.Green("Added: " + bytefmt.ByteSize(added))
	color.Yellow("Removed: " + bytefmt.ByteSize(removed))

	diff := int64(added) - int64(removed)
	if diff < 0 {
		color.Yellow("= Net total: -" + bytefmt.ByteSize(uint64(-diff)))
	} else {
		color.Green("= Net total: " + bytefmt.ByteSize(uint64(diff)))
	}
}

func main() {
	var delete = false
	flag.BoolVar(&delete, "delete", false, "Delete all JPG sidecar files.")
	flag.Parse()

	if len(flag.Args()) < 1 {
		log.Fatalf("Must supply a path to a Lightroom catalog file.")
	}
	path := flag.Args()[0]
	log.Printf("Processing %s", path)

	catalog, err := NewCatalog(path)
	if err != nil {
		log.Fatal(err)
	}

	if !delete {
		stats := catalog.GetSidecarStats()
		log.Printf("There are %d sidecar entries totalling %s bytes on disk.",
			stats.Count, bytefmt.ByteSize(uint64(stats.TotalSizeBytes)))
		return
	}

	var processed_count uint
	var error_count uint
	var skip_count uint
	var missing_count uint
	var count uint
	catalog.ProcessSidecars(func(sidecarPath string, originalPath string) error {
		if _, err := os.Stat(sidecarPath); err == nil {
			if _, err := os.Stat(originalPath); os.IsNotExist(err) {
				log.Printf("Missing original path for sidecar; Skipping %s", sidecarPath)
				skip_count++
				return nil
			}

			log.Printf("Deleting %s", sidecarPath)
			err = os.Remove(sidecarPath)
			if err != nil {
				log.Printf("Error deleting %s; %v.", sidecarPath, err)
				error_count++
				return err
			} else {
				processed_count++
			}
		} else {
			log.Printf("Missing %s", sidecarPath)
			missing_count++
		}
		count++
		return nil
	})
	log.Printf("Done.")
	log.Printf("   Total:   %d", count)
	log.Printf("   Deleted: %d", processed_count)
	log.Printf("   Skipped: %d", skip_count)
	log.Printf("   Missing: %d", missing_count)
}

func convertSize(s string) string {
	// aus 314572800000 wird 962.1G
	ret, err := strconv.ParseUint(s, 10, 64)
	if err != nil {
		log.Error(err.Error())
		return ""
	}
	str := bytefmt.ByteSize(ret)
	log.Info("Aus " + s + " wurde " + str)
	return str
}

func watchGrabber(g grabber.Grabberer) {
	tick := time.NewTicker(3 * time.Second)
	defer tick.Stop()
	for {
		select {
		case <-tick.C:
			log.Printf("Downloading at %v", bytefmt.ByteSize(uint64(g.Strategy().DownloadRate())))
		case <-g.PostProcessable():
			return
		}
	}
}

func MemStat() MemStatus {
	// self mem stat
	memStat := new(runtime.MemStats)
	runtime.ReadMemStats(memStat)
	mem := MemStatus{}
	mem.Self = memStat.Alloc
	// system mem stat
	sysInfo := new(syscall.Sysinfo_t)
	err := syscall.Sysinfo(sysInfo)
	if err == nil {
		mem.All = uint64(sysInfo.Totalram)
		mem.Free = uint64(sysInfo.Freeram)
		mem.Used = mem.All - mem.Free
	}
	fmt.Println("",
		"Self Alloc:", mem.Self, bytefmt.ByteSize(mem.Self), "\n",
		"All:", mem.All, bytefmt.ByteSize(mem.All), "\n",
		"Used:", mem.Used, bytefmt.ByteSize(mem.Used), "\n",
		"Free:", mem.Free, bytefmt.ByteSize(mem.Free),
	)
	return mem
}

func (factory *AppExaminerCommandFactory) printInstanceSummary(writer io.Writer, actualInstances []app_examiner.InstanceInfo) {
	w := tabwriter.NewWriter(writer, minColumnWidth, 8, 1, '\t', 0)

	printHorizontalRule(w, "=")
	fmt.Fprintf(w, fmt.Sprintf("%s\t%s\t%s\t%s\t%s\t%s\n",
		"Instance",
		colors.NoColor("State")+"    ",
		"Crashes",
		"CPU",
		"Memory",
		"Uptime"),
	)
	printHorizontalRule(w, "-")

	for _, instance := range actualInstances {
		metricsSlice := []string{"N/A", "N/A"}
		if instance.HasMetrics {
			metricsSlice = []string{
				fmt.Sprintf("%.2f%%", instance.Metrics.CpuPercentage),
				fmt.Sprintf("%s", bytefmt.ByteSize(instance.Metrics.MemoryBytes)),
			}
		}
		if instance.PlacementError == "" && instance.State != "CRASHED" {
			uptime := factory.clock.Now().Sub(time.Unix(0, instance.Since))
			roundedUptime := uptime - (uptime % time.Second)
			fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\n",
				strconv.Itoa(instance.Index),
				presentation.PadAndColorInstanceState(instance),
				strconv.Itoa(instance.CrashCount),
				strings.Join(metricsSlice, "\t"),
				fmt.Sprint(roundedUptime),
			)
		} else {
			fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\n",
				strconv.Itoa(instance.Index),
				presentation.PadAndColorInstanceState(instance),
				strconv.Itoa(instance.CrashCount),
				strings.Join(metricsSlice, "\t"),
				"N/A",
			)
		}
	}

	w.Flush()
}

func download(uri string, folder string, httpClient *http.Client, fileName string) (path string, newEpisode bool, err error) {
	fileName = filepath.Join(folder, fileName)
	fileName = sanitize.Path(fileName)
	logger.Debug.Println("Local resource path : " + fileName)
	tmpFilename := fileName + ".part"
	resourceName := filepath.Base(folder) + " - " + filepath.Base(fileName)
	defer removeTempFile(tmpFilename)

	if !pathExists(fileName) {
		logger.Debug.Println("New resource available : " + resourceName)
		// TODO: check file existence first with io.IsExist
		output, err := os.Create(tmpFilename)
		if err != nil {
			return fileName, newEpisode, err

		}
		defer output.Close()
		req, err := http.NewRequest("GET", uri, nil)
		if err != nil {
			return fileName, newEpisode, err

		}
		req.Close = true
		response, err := httpClient.Do(req)
		if err != nil {
			return fileName, newEpisode, err

		}
		defer response.Body.Close()
		n, err := io.Copy(output, response.Body)
		if err != nil {
			return fileName, newEpisode, err

		}
		logger.Debug.Println("Resource downloaded : " + resourceName + " (" + bytefmt.ByteSize(uint64(n)) + ")")
		os.Rename(tmpFilename, fileName)
		newEpisode = true

	} else {
		logger.Debug.Println("No download since the file exists", fileName)
		newEpisode = false
	}

	return fileName, newEpisode, err
}

func (t *TerminalUI) AdjustDisk(stats Statistics) {
	var quota int64
	var data []int
	for i, idx := range stats.Instances {
		// show max 8 instances
		if i > 7 {
			break
		}

		mb := int((stats.Data[idx].Stats.Usage.Disk / 1024) / 1024)
		data = append(data, mb)

		quota = stats.Data[idx].Stats.DiskQuota
	}
	t.Disk.Data = data
	t.Disk.BarWidth = 20 - min(len(stats.Instances), 8)
	t.Disk.Border.Label = fmt.Sprintf("Disk Usage (in MB) - Quota: %s", bytefmt.ByteSize(uint64(quota)))
}

func (factory *AppExaminerCommandFactory) printInstanceInfo(writer io.Writer, actualInstances []app_examiner.InstanceInfo) {
	w := tabwriter.NewWriter(writer, minColumnWidth, 8, 1, '\t', 0)

	instanceBar := func(index, state string) {
		fmt.Fprintf(w, "%sInstance %s  [%s]\n", indentHeading, index, state)
		printHorizontalRule(w, "-")
	}

	printHorizontalRule(w, "=")

	for _, instance := range actualInstances {

		instanceBar(fmt.Sprint(instance.Index), presentation.ColorInstanceState(instance))

		if instance.PlacementError == "" && instance.State != "CRASHED" {
			fmt.Fprintf(w, "%s\t%s\n", "InstanceGuid", instance.InstanceGuid)
			fmt.Fprintf(w, "%s\t%s\n", "Cell ID", instance.CellID)
			fmt.Fprintf(w, "%s\t%s\n", "Ip", instance.Ip)

			portMappingStrings := make([]string, 0)
			for _, portMapping := range instance.Ports {
				portMappingStrings = append(portMappingStrings, fmt.Sprintf("%d:%d", portMapping.HostPort, portMapping.ContainerPort))
			}
			fmt.Fprintf(w, "%s\t%s\n", "Port Mapping", strings.Join(portMappingStrings, ";"))
			uptime := factory.clock.Now().Sub(time.Unix(0, instance.Since))
			roundedUptime := uptime - (uptime % time.Second)
			fmt.Fprintf(w, "%s\t%s\n", "Uptime", fmt.Sprint(roundedUptime))

		} else if instance.State != "CRASHED" {
			fmt.Fprintf(w, "%s\t%s\n", "Placement Error", instance.PlacementError)
		}

		fmt.Fprintf(w, "%s \t%d \n", "Crash Count", instance.CrashCount)

		if instance.HasMetrics {
			fmt.Fprintf(w, "%s \t%.2f%% \n", "CPU", instance.Metrics.CpuPercentage)
			fmt.Fprintf(w, "%s \t%s \n", "Memory", bytefmt.ByteSize(instance.Metrics.MemoryBytes))
		}
		printHorizontalRule(w, "-")
	}

	w.Flush()
}