本文整理汇总了Golang中github.com/sburnett/transformer/store.Manager类的典型用法代码示例。如果您正苦于以下问题：Golang Manager类的具体用法？Golang Manager怎么用？Golang Manager使用的例子？那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了Manager类的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: makeSummaryByTimestampCsvWriter
func makeSummaryByTimestampCsvWriter(manager store.Manager, name string) store.Writer {
keyNames := []string{
"experiment",
"node",
"timestamp",
}
valueNames := []string{
"count",
}
for _, i := range []int{0, 1, 5, 10, 25, 50, 75, 90, 95, 99, 100} {
valueNames = append(valueNames, humanize.Ordinal(i))
}
arguments := []interface{}{
name,
keyNames,
valueNames,
new(string), // experiment
new(string), // node
new(int64), // timestamp
new(int64), // count
}
for _ = range []int{0, 1, 5, 10, 25, 50, 75, 90, 95, 99, 100} {
arguments = append(arguments, new(int64))
}
return manager.Writer(arguments...)
}示例2: PackagesPipeline
func PackagesPipeline(levelDbManager, csvManager, sqliteManager store.Manager) transformer.Pipeline {
logsStore := levelDbManager.Seeker("logs")
installedPackagesStore := levelDbManager.ReadingWriter("installed-packages")
versionChangesStore := levelDbManager.ReadingWriter("version-changes")
var node, packageName string
var timestamp int64
var version string
csvStore := csvManager.Writer("packages.csv", []string{"node", "package", "timestamp"}, []string{"version"}, &node, &packageName, ×tamp, &version)
sqliteStore := sqliteManager.Writer("packages", []string{"node", "package", "timestamp"}, []string{"version"}, &node, &packageName, ×tamp, &version)
return []transformer.PipelineStage{
transformer.PipelineStage{
Name: "OpkgListInstalled",
Reader: ReadOnlySomeLogs(logsStore, "opkg_list-installed"),
Transformer: transformer.MakeDoFunc(extractInstalledPackages),
Writer: installedPackagesStore,
},
transformer.PipelineStage{
Name: "DetectVersionChanges",
Reader: installedPackagesStore,
Transformer: transformer.TransformFunc(detectChangedPackageVersions),
Writer: versionChangesStore,
},
transformer.PipelineStage{
Name: "WriteVersionChangesSqlite",
Reader: versionChangesStore,
Writer: sqliteStore,
},
transformer.PipelineStage{
Name: "WriteVersionChangesCsv",
Reader: versionChangesStore,
Writer: csvStore,
},
}
}示例3: FilterNodesPipeline
func FilterNodesPipeline(nodeId string, levelDbManager store.Manager) transformer.Pipeline {
tracesStore := levelDbManager.Seeker("traces")
filteredStore := levelDbManager.Writer(fmt.Sprintf("filtered-%s", nodeId))
return []transformer.PipelineStage{
transformer.PipelineStage{
Name: "FilterNode",
Reader: FilterNodes(tracesStore, nodeId),
Writer: filteredStore,
},
}
}示例4: CsvPipeline
func CsvPipeline(levelDbManager, csvManager store.Manager) transformer.Pipeline {
var experiment, node, filename string
var receivedTimestamp, creationTimestamp, size int64
csvStore := csvManager.Writer("stats.csv", []string{"experiment", "node", "filename"}, []string{"received_timestamp", "creation_timestamp", "size"}, &experiment, &node, &filename, &receivedTimestamp, &creationTimestamp, &size)
return []transformer.PipelineStage{
transformer.PipelineStage{
Name: "WriteStatsCsv",
Reader: levelDbManager.Reader("stats"),
Writer: csvStore,
},
}
}示例5: RebootsPipeline
func RebootsPipeline(levelDbManager, csvManager, sqliteManager store.Manager) transformer.Pipeline {
uptimeStore := levelDbManager.Seeker("uptime")
rebootsStore := levelDbManager.ReadingWriter("reboots")
var node string
var timestamp int64
rebootsCsvStore := csvManager.Writer("reboots.csv", []string{"node", "boot_timestamp"}, []string{}, &node, ×tamp)
rebootsSqliteStore := sqliteManager.Writer("reboots", []string{"node", "boot_timestamp"}, []string{}, &node, ×tamp)
return []transformer.PipelineStage{
transformer.PipelineStage{
Name: "InferReboots",
Reader: uptimeStore,
Transformer: transformer.TransformFunc(inferReboots),
Writer: rebootsStore,
},
transformer.PipelineStage{
Name: "WriteRebootsCsv",
Reader: rebootsStore,
Writer: rebootsCsvStore,
},
transformer.PipelineStage{
Name: "WriteRebootsSqlite",
Reader: rebootsStore,
Writer: rebootsSqliteStore,
},
}
}示例6: UptimePipeline
func UptimePipeline(levelDbManager, csvManager, sqliteManager store.Manager) transformer.Pipeline {
logsStore := levelDbManager.Seeker("logs")
uptimeStore := levelDbManager.ReadingWriter("uptime")
var node string
var timestamp, uptime int64
csvStore := csvManager.Writer("uptime.csv", []string{"node", "timestamp"}, []string{"uptime"}, &node, ×tamp, &uptime)
sqliteStore := sqliteManager.Writer("uptime", []string{"node", "timestamp"}, []string{"uptime"}, &node, ×tamp, &uptime)
return []transformer.PipelineStage{
transformer.PipelineStage{
Name: "Uptime",
Reader: ReadOnlySomeLogs(logsStore, "uptime"),
Transformer: transformer.MakeMapFunc(extractUptime),
Writer: uptimeStore,
},
transformer.PipelineStage{
Name: "WriteUptimeCsv",
Reader: uptimeStore,
Writer: csvStore,
},
transformer.PipelineStage{
Name: "WriteUptimeSqlite",
Reader: uptimeStore,
Writer: sqliteStore,
},
}
}示例7: MemoryUsagePipeline
func MemoryUsagePipeline(levelDbManager, csvManager, sqliteManager store.Manager) transformer.Pipeline {
logsStore := levelDbManager.Seeker("logs")
memoryUsageStore := levelDbManager.ReadingWriter("memory")
var node string
var timestamp, used, free int64
csvStore := csvManager.Writer("memory.csv", []string{"node", "timestamp"}, []string{"used", "free"}, &node, ×tamp, &used, &free)
sqliteStore := sqliteManager.Writer("memory", []string{"node", "timestamp"}, []string{"used", "free"}, &node, ×tamp, &used, &free)
return []transformer.PipelineStage{
transformer.PipelineStage{
Name: "Memory",
Reader: ReadOnlySomeLogs(logsStore, "top"),
Transformer: transformer.MakeDoFunc(extractMemoryUsage),
Writer: memoryUsageStore,
},
transformer.PipelineStage{
Name: "WriteMemoryUsageCsv",
Reader: memoryUsageStore,
Writer: csvStore,
},
transformer.PipelineStage{
Name: "WriteMemoryUsageSqlite",
Reader: memoryUsageStore,
Writer: sqliteStore,
},
}
}示例8: DevicesCountPipeline
func DevicesCountPipeline(levelDbManager store.Manager) transformer.Pipeline {
logsStore := levelDbManager.Seeker("logs")
devicesCountStore := levelDbManager.Writer("devices-count")
return []transformer.PipelineStage{
transformer.PipelineStage{
Name: "ExtractEthernetCount",
Reader: ReadOnlySomeLogs(logsStore, "swconfig_ports"),
Transformer: transformer.MakeDoFunc(extractEthernetCount),
Writer: devicesCountStore,
},
transformer.PipelineStage{
Name: "ExtractWirelessCount",
Reader: ReadOnlySomeLogs(logsStore, "iw_station_count"),
Transformer: transformer.MakeDoFunc(extractWirelessCount),
Writer: devicesCountStore,
},
}
}示例9: TimesCsvPipeline
func TimesCsvPipeline(levelDbManager store.Manager, csvRoot string) transformer.Pipeline {
writeTimesCsv := func(inputChan, outputChan chan *store.Record) {
var currentHandle *os.File
var currentExperiment, currentNode string
for record := range inputChan {
var statsKey StatsKey
lex.DecodeOrDie(record.Key, &statsKey)
var statsValue StatsValue
lex.DecodeOrDie(record.Value, &statsValue)
if currentExperiment != statsKey.Experiment || currentNode != statsKey.Node {
if currentHandle != nil {
currentHandle.Close()
}
currentExperiment = statsKey.Experiment
currentNode = statsKey.Node
csvName := fmt.Sprintf("%s_%s.csv", currentExperiment, currentNode)
newHandle, err := os.Create(filepath.Join(csvRoot, csvName))
if err != nil {
panic(err)
}
currentHandle = newHandle
}
if _, err := fmt.Fprintf(currentHandle, "%d,%d\n", statsValue.CreationTimestamp, statsValue.ReceivedTimestamp); err != nil {
panic(err)
}
}
if currentHandle != nil {
currentHandle.Close()
}
}
return []transformer.PipelineStage{
transformer.PipelineStage{
Name: "WriteTimesCsv",
Reader: levelDbManager.Reader("stats"),
Transformer: transformer.TransformFunc(writeTimesCsv),
},
}
}示例10: runFilterSessionsPipeline
func runFilterSessionsPipeline(startSecs, endSecs int64, levelDbManager store.Manager) {
transformer.RunPipeline(FilterSessionsPipeline(startSecs, endSecs, levelDbManager, "test"))
filteredStore := levelDbManager.Reader("test")
filteredStore.BeginReading()
for {
record, err := filteredStore.ReadRecord()
if err != nil {
panic(err)
}
if record == nil {
break
}
var traceKey TraceKey
lex.DecodeOrDie(record.Key, &traceKey)
fmt.Printf("%s %d %d\n", traceKey.NodeId, traceKey.SessionId, traceKey.SequenceNumber)
}
filteredStore.EndReading()
}示例11: IndexTarballsPipeline
func IndexTarballsPipeline(tarballsPath string, levelDbManager store.Manager) transformer.Pipeline {
allTarballsPattern := filepath.Join(tarballsPath, "all", "health", "*", "*", "health_*.tar.gz")
dailyTarballsPattern := filepath.Join(tarballsPath, "by-date", "*", "health", "*", "health_*.tar.gz")
tarnamesStore := levelDbManager.ReadingWriter("tarnames")
tarnamesIndexedStore := levelDbManager.ReadingWriter("tarnames-indexed")
logsStore := levelDbManager.Writer("logs")
return []transformer.PipelineStage{
transformer.PipelineStage{
Name: "ScanLogTarballs",
Reader: store.NewGlobReader(allTarballsPattern),
Writer: tarnamesStore,
},
transformer.PipelineStage{
Name: "ScanDailyLogTarballs",
Reader: store.NewGlobReader(dailyTarballsPattern),
Writer: tarnamesStore,
},
transformer.PipelineStage{
Name: "ReadLogTarballs",
Reader: store.NewDemuxingReader(tarnamesStore, tarnamesIndexedStore),
Transformer: transformer.MakeMultipleOutputsGroupDoFunc(IndexTarballs, 2),
Writer: store.NewMuxingWriter(logsStore, tarnamesIndexedStore),
},
}
}示例12: makeSummaryCsvWriter
func makeSummaryCsvWriter(manager store.Manager, name string) store.Writer {
keyNames := []string{
"experiment",
"node",
}
valueNames := []string{
"count",
}
for i := 0; i <= 100; i += 5 {
valueNames = append(valueNames, humanize.Ordinal(i))
}
arguments := []interface{}{
name,
keyNames,
valueNames,
new(string), // experiment
new(string), // node
new(int64), // count
}
for i := 0; i <= 100; i += 5 {
arguments = append(arguments, new(int64))
}
return manager.Writer(arguments...)
}示例13: FilterSessionsPipeline
func FilterSessionsPipeline(sessionStartTime, sessionEndTime int64, levelDbManager store.Manager, outputName string) transformer.Pipeline {
tracesStore := levelDbManager.Reader("traces")
traceKeyRangesStore := levelDbManager.Reader("availability-done")
filteredStore := levelDbManager.Writer(outputName)
parameters := filterSessions{
SessionStartTime: sessionStartTime * 1000000,
SessionEndTime: sessionEndTime * 1000000,
}
return []transformer.PipelineStage{
transformer.PipelineStage{
Name: "FilterSessions",
Reader: store.NewDemuxingReader(traceKeyRangesStore, tracesStore),
Transformer: parameters,
Writer: filteredStore,
},
}
}示例14: IndexTarballsPipeline
func IndexTarballsPipeline(tarballsPath string, levelDbManager store.Manager) transformer.Pipeline {
tarballsPattern := filepath.Join(tarballsPath, "*", "*", "*.tar.gz")
tarnamesStore := levelDbManager.ReadingWriter("tarnames")
tarnamesIndexedStore := levelDbManager.ReadingWriter("tarnames-indexed")
tracesStore := levelDbManager.Writer("traces")
return []transformer.PipelineStage{
transformer.PipelineStage{
Name: "ScanTraceTarballs",
Reader: store.NewGlobReader(tarballsPattern),
Writer: tarnamesStore,
},
transformer.PipelineStage{
Name: "IndexTraces",
Transformer: transformer.MakeMultipleOutputsGroupDoFunc(IndexTarballs, 2),
Reader: store.NewDemuxingReader(tarnamesStore, tarnamesIndexedStore),
Writer: store.NewMuxingWriter(tracesStore, tarnamesIndexedStore),
},
}
}示例15: DisjointPackagesPipeline
func DisjointPackagesPipeline(levelDbManager, csvManager store.Manager) transformer.Pipeline {
logsStore := levelDbManager.Seeker("logs")
disjointPackagesStore := levelDbManager.ReadingWriter("disjoint-packages")
var filename, node string
var timestamp int64
csvStore := csvManager.Writer("not-disjoint.csv", []string{"filename", "node", "timestamp"}, []string{}, &filename, &node, ×tamp)
return []transformer.PipelineStage{
transformer.PipelineStage{
Name: "DisjointPackages",
Reader: logsStore,
Transformer: transformer.MakeDoFunc(detectDisjointPackagesError),
Writer: disjointPackagesStore,
},
transformer.PipelineStage{
Name: "WriteDisjointPackagesCsv",
Reader: disjointPackagesStore,
Writer: csvStore,
},
}
}