Golang configuration.Configuration類代碼示例

// NewURLChecker creates new instance of URL checker.
func NewURLChecker(configuration *configuration.Configuration) *URLChecker {
	return &URLChecker{
		client:        createHTTPClient(configuration),
		baseURL:       configuration.BaseURL(),
		headers:       createHTTPHeaders(configuration),
		httpErrorCode: int(configuration.HTTPErrorCode()),
		waitPeriod:    configuration.WorkerWaitPeriod(),
	}
}

func createHTTPHeaders(configuration *configuration.Configuration) http.Header {
	preparedHeaders := http.Header{}

	if headers, exists := configuration.Headers(); exists {
		for name, value := range headers {
			preparedHeaders[name] = []string{value}
		}
	}

	return preparedHeaders
}

// NewFileWriter creates new instance of a file writer.
func NewFileWriter(configuration *configuration.Configuration) *FileWriter {
	var outputFile *os.File
	var error error

	path, defined := configuration.OutputFile()
	if defined {
		log.Printf("Opening file \"%v\" for writing.", path)

		outputFile, error = os.Create(path)
		if nil != error {
			log.Fatalf("Error occured while opening file \"%v\", error: %v", path, error)
		}
	}

	return &FileWriter{outputFile: outputFile}
}

// NewFuzz creates a fuzz URL flow with defined components and links.
func NewFuzz(configuration *configuration.Configuration) *Fuzz {
	graph := new(flow.Graph)
	graph.InitGraphState()

	entryProducer := httpmethod.NewEntryProducer(configuration)
	entryProducer.Component.Mode = flow.ComponentModePool
	entryProducer.Component.PoolSize = 8

	urlChecker := httprequest.NewURLChecker(configuration)
	urlChecker.Component.Mode = flow.ComponentModePool
	urlChecker.Component.PoolSize = uint8(configuration.WorkersNumber())

	resultBroadcaster := broadcaster.NewResultBroadcaster(configuration)
	resultBroadcaster.Component.Mode = flow.ComponentModePool
	resultBroadcaster.Component.PoolSize = 1

	printer := printer.NewPrinter()
	printer.Component.Mode = flow.ComponentModePool
	printer.Component.PoolSize = 1

	fileWriter := filewriter.NewFileWriter(configuration)
	printer.Component.Mode = flow.ComponentModePool
	printer.Component.PoolSize = 1

	graph.Add(entryProducer, "entryProducer")
	graph.Add(urlChecker, "urlChecker")
	graph.Add(resultBroadcaster, "resultBroadcaster")
	graph.Add(printer, "printer")
	graph.Add(fileWriter, "fileWriter")
	graph.Connect("entryProducer", "Entry", "urlChecker", "Entry")
	graph.Connect("urlChecker", "FoundEntry", "resultBroadcaster", "FoundEntry")
	graph.Connect("resultBroadcaster", "Printer", "printer", "FoundEntry")
	graph.Connect("resultBroadcaster", "FileWriter", "fileWriter", "FoundEntry")
	graph.MapInPort("In", "entryProducer", "RelativeURL")

	var input = make(chan string, fuzzNetworkInputSize)
	graph.SetInPort("In", input)

	return &Fuzz{graph: graph, input: input, configuration: configuration}
}

// NewEntryProducer creates an instance of entry producer.
func NewEntryProducer(configuration *configuration.Configuration) *EntryProducer {
	methods := configuration.Methods()
	return &EntryProducer{methods: methods}
}

func newFileReader(configuration *configuration.Configuration) *fileReader {
	inputFile := configuration.FuzzSetFile()
	return &fileReader{inputFile: inputFile}
}

// NewResultBroadcaster creates new instance of result broadcaster.
func NewResultBroadcaster(configuration *configuration.Configuration) *ResultBroadcaster {
	_, isDefined := configuration.OutputFile()
	return &ResultBroadcaster{isOutputFileDefined: isDefined}
}

func createHTTPClient(configuration *configuration.Configuration) *http.Client {
	tr := &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}}
	client := &http.Client{Transport: tr, Timeout: configuration.URLResponseTimeout()}
	return client
}