Ejemplo n.º 1
0
func (c *restoreRun) main(a DumbcasApplication, nodeArg string) error {
	if err := c.Parse(a, true); err != nil {
		return err
	}

	// Load the Node and process it.
	// Do it serially for now, assuming that it is I/O bound on magnetic disks.
	// For a network CAS, it would be good to implement concurrent fetches.

	f, err := c.nodes.Open(nodeArg)
	if err != nil {
		return err
	}
	defer func() {
		_ = f.Close()
	}()
	node := &dumbcaslib.Node{}
	if err := dumbcaslib.LoadReaderAsJSON(f, node); err != nil {
		return err
	}

	entry, err := dumbcaslib.LoadEntry(c.cas, node.Entry)
	if err != nil {
		return err
	}
	// TODO(maruel): Progress bar.
	count, err := restoreEntry(a.GetLog(), c.cas, entry, c.Out)
	fmt.Fprintf(a.GetOut(), "Restored %d files in %s\n", count, c.Out)
	return err
}
Ejemplo n.º 2
0
func (c *infoRun) main(a DumbcasApplication, nodeArg string) error {
	if err := c.Parse(a, true); err != nil {
		return err
	}

	// Load the Node and process it.
	f, err := c.nodes.Open(nodeArg)
	if err != nil {
		return err
	}
	defer func() {
		_ = f.Close()
	}()
	node := &dumbcaslib.Node{}
	if err := dumbcaslib.LoadReaderAsJSON(f, node); err != nil {
		return err
	}

	entry, err := dumbcaslib.LoadEntry(c.cas, node.Entry)
	if err != nil {
		return err
	}

	count := printEntry(a.GetOut(), entry, "")
	fmt.Fprintf(a.GetOut(), "Total %d\n", count)
	return nil
}
Ejemplo n.º 3
0
Archivo: gc.go Proyecto: maruel/dumbcas
func (c *gcRun) main(a DumbcasApplication) error {
	if err := c.Parse(a, false); err != nil {
		return err
	}

	entries := map[string]bool{}
	for item := range c.cas.Enumerate() {
		if item.Error != nil {
			// TODO(maruel): Leaks channel.
			c.cas.SetFsckBit()
			return fmt.Errorf("Failed enumerating the CAS table %s", item.Error)
		}
		entries[item.Item] = false
	}
	a.GetLog().Printf("Found %d entries", len(entries))

	// Load all the nodes.
	for item := range c.nodes.Enumerate() {
		if item.Error != nil {
			// TODO(maruel): Leaks channel.
			return item.Error
		}
		f, err := c.nodes.Open(item.Item)
		if err != nil {
			// TODO(maruel): Leaks channel.
			c.cas.SetFsckBit()
			return fmt.Errorf("Failed opening node %s: %s", item.Item, err)
		}
		defer func() {
			_ = f.Close()
		}()
		node := &dumbcaslib.Node{}
		if err := dumbcaslib.LoadReaderAsJSON(f, node); err != nil {
			// TODO(maruel): Leaks channel.
			c.cas.SetFsckBit()
			return fmt.Errorf("Failed opening node %s: %s", item.Item, err)
		}

		entries[node.Entry] = true
		entry, err := dumbcaslib.LoadEntry(c.cas, node.Entry)
		if err != nil {
			return err
		}
		tagRecurse(entries, entry)
	}

	orphans := []string{}
	for entry, tagged := range entries {
		if !tagged {
			orphans = append(orphans, entry)
		}
	}
	a.GetLog().Printf("Found %d orphan", len(orphans))
	for _, orphan := range orphans {
		if err := c.cas.Remove(orphan); err != nil {
			c.cas.SetFsckBit()
			return fmt.Errorf("Internal error while removing %s: %s", orphan, err)
		}
	}
	return nil
}
Ejemplo n.º 4
0
func (c *fsckRun) main(a DumbcasApplication) error {
	if err := c.Parse(a, true); err != nil {
		return err
	}

	count := 0
	corrupted := 0
	for item := range c.cas.Enumerate() {
		if item.Error != nil {
			a.GetLog().Printf("While enumerating the CAS table: %s", item.Error)
			continue
		}
		count++
		f, err := c.cas.Open(item.Item)
		if err != nil {
			// TODO(maruel): Leaks channel.
			return fmt.Errorf("Failed to open %s: %s", item.Item, err)
		}
		defer func() {
			_ = f.Close()
		}()
		actual, err := sha1Reader(f)
		if err != nil {
			// Probably Disk error.
			// TODO(maruel): Leaks channel.
			return fmt.Errorf("Aborting! Failed to calcultate the sha1 of %s: %s. Please find a valid copy of your CAS table ASAP.", item.Item, err)
		}
		if actual != item.Item {
			corrupted++
			a.GetLog().Printf("Found corrupted object, %s != %s", item.Item, actual)
			if err := c.cas.Remove(item.Item); err != nil {
				// TODO(maruel): Leaks channel.
				return fmt.Errorf("Failed to trash object %s: %s", item.Item, err)
			}
		}
	}
	a.GetLog().Printf("Scanned %d entries in CasTable; found %d corrupted.", count, corrupted)

	// TODO(maruel): Get the value from CasTable.
	hashLength := 40
	resha1 := regexp.MustCompile(fmt.Sprintf("^([a-f0-9]{%d})$", hashLength))
	count = 0
	corrupted = 0
	for item := range c.nodes.Enumerate() {
		// TODO(maruel): Can't differentiate between an I/O error or a corrupted node.
		// NodesTable.Enumerate() automatically clears corrupted nodes.
		// TODO(maruel): This is a layering error.
		if item.Error != nil {
			a.GetLog().Printf("While enumerating the Nodes table: %s", item.Error)
			continue
		}
		count++
		f, err := c.nodes.Open(item.Item)
		if err != nil {
			a.GetLog().Printf("Failed opening node %s: %s", item.Item, err)
			_ = c.nodes.Remove(item.Item)
			corrupted++
			continue
		}
		defer func() {
			_ = f.Close()
		}()
		node := &dumbcaslib.Node{}
		if err := dumbcaslib.LoadReaderAsJSON(f, node); err != nil {
			a.GetLog().Printf("Failed opening node %s: %s", item.Item, err)
			_ = c.nodes.Remove(item.Item)
			corrupted++
			continue
		}
		if !resha1.MatchString(node.Entry) {
			a.GetLog().Printf("Node %s is corrupted: %v", item.Item, node)
			_ = c.nodes.Remove(item.Item)
			corrupted++
			continue
		}
	}
	a.GetLog().Printf("Scanned %d entries in NodesTable; found %d corrupted.", count, corrupted)

	c.cas.ClearFsckBit()
	return nil
}