Пример #1
0
Файл: dump.go Проект: e4x/cayley
// Dump the content of the database into a file based
// on a few different formats
func Dump(qs graph.QuadStore, outFile, typ string) error {
	var f *os.File
	if outFile == "-" {
		f = os.Stdout
	} else {
		var err error
		f, err = os.Create(outFile)
		if err != nil {
			return fmt.Errorf("could not open file %q: %v", outFile, err)
		}
		defer f.Close()
		fmt.Printf("dumping db to file %q\n", outFile)
	}

	var export *exporter.Exporter
	if filepath.Ext(outFile) == ".gz" {
		gzip := gzip.NewWriter(f)
		defer gzip.Close()
		export = exporter.NewExporter(gzip, qs)
	} else {
		export = exporter.NewExporter(f, qs)
	}

	//TODO: add possible support for exporting specific queries only
	switch typ {
	case "quad":
		export.ExportQuad()
	case "json":
		export.ExportJson()
	// gml/graphml experimental
	case "gml":
		export.ExportGml()
	case "graphml":
		export.ExportGraphml()
	default:
		return fmt.Errorf("unknown format %q", typ)
	}

	if export.Err() != nil {
		return export.Err()
	}

	if outFile != "-" {
		fmt.Printf("%d entries were written\n", export.Count())
	}
	return nil
}
Пример #2
0
// Dump the content of the database into a file based
// on a few different formats
func Dump(qs graph.QuadStore, outFile, typ string) error {
	var f *os.File
	if outFile == "-" {
		f = os.Stdout
	} else {
		var err error
		f, err = os.Create(outFile)
		if err != nil {
			return fmt.Errorf("could not open file %q: %v", outFile, err)
		}
		defer f.Close()
		fmt.Printf("dumping db to file %q\n", outFile)
	}

	var w io.Writer = f
	if filepath.Ext(outFile) == ".gz" {
		gzip := gzip.NewWriter(f)
		defer gzip.Close()
		w = gzip
	}
	qr := graph.NewQuadReader(qs) //TODO: add possible support for exporting specific queries only

	if typ == "quad" { // compatibility
		typ = "nquads"
	}
	format := quad.FormatByName(typ)
	if format == nil {
		return fmt.Errorf("unknown format %q", typ)
	} else if format.Writer == nil {
		return fmt.Errorf("format %q: encoding is not supported", typ)
	}
	qw := format.Writer(w)
	count, err := quad.Copy(qw, qr)
	if err != nil {
		qw.Close()
		return err
	}
	if err = qw.Close(); err != nil {
		return err
	}
	if outFile != "-" {
		fmt.Printf("%d entries were written\n", count)
	}
	return nil
}
Пример #3
0
func save(file, passphrase string, sites []Site) error {
	// If the file doesn't exist then create it
	if _, err := os.Stat(file); os.IsNotExist(err) {
		_, err = os.Create(file)
		if err != nil {
			return err
		}
	}

	// Marshal the JSON
	b, err := json.Marshal(sites)
	if err != nil {
		return err
	}
	b, err = encrypt(encodeBase64(b), passphrase)
	if err != nil {
		return err
	}

	// Compress the contents
	var buffer bytes.Buffer
	gzip := gzip.NewWriter(&buffer)
	if err != nil {
		return err
	}
	gzip.Write(b)
	gzip.Close()

	// Write to the file
	fi, err := os.OpenFile(file, os.O_WRONLY, 0666)
	if err != nil {
		return err
	}
	_, err = fi.Write(buffer.Bytes())
	if err != nil {
		return err
	}
	fi.Close()

	return nil
}
Пример #4
0
// DecodedData returns the Base64 decoded, gunzip'd decoded data per
// http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/Subscriptions.html
// You should expect to see a response with an array of Amazon Kinesis.
// The Data attribute in the Amazon Kinesis record is Base64 encoded and compressed
// with the gzip format. You can examine the raw data from the command line
// using the following Unix commands:
// echo -n "<Content of Data>" | base64 -d | zcat
func (awsLogs *AWSLogs) DecodedData() (*CloudWatchLogEvent, error) {
	data, err := base64.StdEncoding.DecodeString(awsLogs.Data)
	if err != nil {
		return nil, err
	}
	in := bytes.NewReader(data)
	gzip, err := gzip.NewReader(in)
	if nil != err {
		return nil, err
	}
	defer gzip.Close()
	allData, err := ioutil.ReadAll(gzip)
	if err != nil {
		return nil, err
	}

	var cloudWatchEvent CloudWatchLogEvent
	err = json.Unmarshal(allData, &cloudWatchEvent)
	if nil != err {
		return nil, err
	}
	return &cloudWatchEvent, nil
}
Пример #5
0
// Read the password book
func read(file, passphrase string) ([]Site, error) {
	// If the file doesn't exist yet no worries
	if _, err := os.Stat(file); os.IsNotExist(err) {
		return []Site{}, nil
	}

	// Bring in the compressed data
	fi, err := os.Open(file)
	if err != nil {
		return nil, err
	}

	// Decompress the file contents
	gzip, err := gzip.NewReader(fi)
	if err != nil {
		return nil, err
	}
	decompressed, err := ioutil.ReadAll(gzip)
	gzip.Close()

	// Decrypt the contents
	decompressed, err = decrypt(decompressed, passphrase)
	if err != nil {
		return nil, err
	}
	decompressed = decodeBase64(decompressed)

	// Unmarshal the JSON information
	var sites []Site
	err = json.Unmarshal(decompressed, &sites)
	if err != nil {
		return nil, err
	}
	fi.Close()

	return sites, nil
}