github.com/scottcagno/storage@v1.8.0/cmd/blockfile/main.go (about)

     1  package main
     2  
     3  import (
     4  	"errors"
     5  	"fmt"
     6  	"github.com/scottcagno/storage/pkg/lsmtree"
     7  	"github.com/scottcagno/storage/pkg/util"
     8  	"io"
     9  	"log"
    10  	"math"
    11  	"os"
    12  )
    13  
    14  func main() {
    15  
    16  	n := math.MaxUint16
    17  	x := make([]int64, n)
    18  	s := util.Sizeof(x)
    19  	fmt.Printf("x := make([]int64, %d) is %dbytes, %dkb, %dmb\n", n, s, s/1000, s/1000/1000)
    20  
    21  	bf, err := lsmtree.OpenBlockFile("cmd/blockfile/testing/test.txt")
    22  	if err != nil {
    23  		log.Panic(err)
    24  	}
    25  
    26  	at, err := bf.WriteAt([]byte("THIS IS A TEST"), 8192)
    27  	if err != nil {
    28  		panic(err)
    29  	}
    30  	fmt.Printf(">>>>>>>>>>>>> %v\n", at)
    31  
    32  	da, err := bf.ReadAt(8192)
    33  	if err != nil {
    34  		panic(err)
    35  	}
    36  	fmt.Printf(">>>>>>>>>>>> %q\n", da)
    37  
    38  	bf.Close()
    39  	return
    40  
    41  	// write...
    42  	d1 := []byte("foo bar")
    43  	off, err := bf.Write(d1)
    44  	if err != nil {
    45  		log.Panic(err)
    46  	}
    47  	fmt.Printf("wrote data at offset %d\n", off)
    48  
    49  	// write...
    50  	d2 := []byte("baz nad")
    51  	off, err = bf.Write(d2)
    52  	if err != nil {
    53  		log.Panic(err)
    54  	}
    55  	fmt.Printf("wrote data at offset %d\n", off)
    56  
    57  	// write...
    58  	d3 := []byte("cool beans man")
    59  	off, err = bf.Write(d3)
    60  	if err != nil {
    61  		log.Panic(err)
    62  	}
    63  	fmt.Printf("wrote data at offset %d\n", off)
    64  
    65  	// write...
    66  	d4 := []byte("i really wonder what i can do to make this more idiomatic?")
    67  	off, err = bf.Write(d4)
    68  	if err != nil {
    69  		log.Panic(err)
    70  	}
    71  	fmt.Printf("wrote data at offset %d\n", off)
    72  
    73  	// write...
    74  	d5 := []byte("so far so good, i suppose")
    75  	off, err = bf.Write(d5)
    76  	if err != nil {
    77  		log.Panic(err)
    78  	}
    79  	fmt.Printf("wrote data at offset %d\n", off)
    80  
    81  	// go back to beginning
    82  	_, err = bf.Seek(0, io.SeekStart)
    83  	if err != nil {
    84  		log.Panic(err)
    85  	}
    86  
    87  	// read...
    88  	d, err := bf.Read()
    89  	if err != nil {
    90  		log.Panic(err)
    91  	}
    92  	fmt.Printf("read data: %q\n", d)
    93  
    94  	// read...
    95  	d, err = bf.Read()
    96  	if err != nil {
    97  		log.Panic(err)
    98  	}
    99  	fmt.Printf("read data: %q\n", d)
   100  
   101  	// read...
   102  	d, err = bf.Read()
   103  	if err != nil {
   104  		log.Panic(err)
   105  	}
   106  	fmt.Printf("read data: %q\n", d)
   107  
   108  	// read...
   109  	d, err = bf.Read()
   110  	if err != nil {
   111  		log.Panic(err)
   112  	}
   113  	fmt.Printf("read data: %q\n", d)
   114  
   115  	// read...
   116  	d, err = bf.Read()
   117  	if err != nil {
   118  		log.Panic(err)
   119  	}
   120  	fmt.Printf("read data: %q\n", d)
   121  
   122  	// read at...
   123  	pos := int64(4096)
   124  	d, err = bf.ReadAt(pos)
   125  	if err != nil {
   126  		log.Panic(err)
   127  	}
   128  	fmt.Printf("read data at offset %d: %q\n", off, d)
   129  
   130  	// read at...
   131  	pos = int64(0)
   132  	d, err = bf.ReadAt(pos)
   133  	if err != nil {
   134  		log.Panic(err)
   135  	}
   136  	fmt.Printf("read data at offset %d: %q\n", off, d)
   137  
   138  	// read at...
   139  	pos = int64(12288)
   140  	d, err = bf.ReadAt(pos)
   141  	if err != nil {
   142  		log.Panic(err)
   143  	}
   144  	fmt.Printf("read data at offset %d: %q\n", off, d)
   145  
   146  	// go back to beginning
   147  	_, err = bf.Seek(0, io.SeekStart)
   148  	if err != nil {
   149  		log.Panic(err)
   150  	}
   151  
   152  	// test scan out
   153  	err = bf.Scan(func(rd *lsmtree.Record) error {
   154  		if rd != nil {
   155  			fmt.Printf("record: %s\n", rd.String())
   156  			return nil
   157  		}
   158  		return errors.New("something went wrong")
   159  	})
   160  	if err != nil {
   161  		log.Panic(err)
   162  	}
   163  
   164  	// close
   165  	err = bf.Close()
   166  	if err != nil {
   167  		log.Panic(err)
   168  	}
   169  
   170  	err = os.RemoveAll("cmd/blockfile/testing/")
   171  	if err != nil {
   172  		log.Panic(err)
   173  	}
   174  }
   175  
   176  func write(w io.Writer, d []byte) {
   177  	off, err := w.Write(d)
   178  	if err != nil {
   179  		log.Panic(err)
   180  	}
   181  	fmt.Printf("wrote data at offset %d\n", off)
   182  }
   183  
   184  var setupDir = func() string {
   185  	dir, err := os.MkdirTemp("dir", "tmp-*")
   186  	if err != nil {
   187  		log.Panic(err)
   188  	}
   189  	return dir
   190  }
   191  
   192  var cleanupDir = func(dir string) {
   193  	err := os.RemoveAll(dir)
   194  	if err != nil {
   195  		log.Panic(err)
   196  	}
   197  }