lookout

package module
v0.2.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 9, 2018 License: AGPL-3.0 Imports: 7 Imported by: 20

README

lookout Build Status GoDoc Code Coverage Go Report Card development

A service for assisted code review, that allows running custom code Analyzers on pull requests.

Table of Contents

Configuring lookout

Please refer to the Configuring lookout guide for documentation for the config.yml file.

Usage

Running lookout with docker-compose

Using Docker Compose you can use the provided docker-compose.yml config file to start lookout, its dependencies (bblfsh and PostgreSQL) and the dummy analyzer which will add some stats to the watched pull requests.

To do so, clone this repository or download docker-compose.yml.

Create the config.yml file in the same directory where docker-compose.yml is, and run:

$ docker-compose pull
$ GITHUB_USER=<user> GITHUB_TOKEN=<token> docker-compose up --force-recreate

If you need to restart the database to a clean state, you can do so with:

$ docker rm lookout_postgres_1

Running lookout from Binaries

Installation

Go to the lookout releases page and download the latest lookoutd and dummy binaries from there.

Dependencies

lookout needs a running instance of:

You will also need to configure external Analyzers, that will perform the actual processing of the pull requests. You may use the included dummy Analyzer for testing purposes.

Quickstart

Following these steps you will be able to run separately the lookout dependencies, analyzers and the server itself.

  1. Run the dependencies manually or using docker-compose, executing:

    $ docker-compose up bblfsh postgres

  2. Initialize the database.
    This command will work for the PostgreSQL created by docker-compose, use -h to see other options.

    $ lookoutd migrate

  3. Start an analyzer before running lookout.
    You can use the dummy one as it is provided by this repository; to do so just run:

    $ dummy serve

  4. Copy the config.yml.tpl into config.yml and add the URLs of the repositories to be watched. Take a look at configuration and GitHub authentication for more details about lookout configuration.

  5. Start lookout server
    If you want to post the analysis results on GitHub, run:

    $ lookoutd serve --github-token <token> --github-user <user>

    If you want to avoid posting the analysis results on GitHub, and only print them, run:

    $ lookoutd serve --dry-run

Available Analyzers

This is a list of the available analyzers for lookout:

Name Description Maturity level
style-analyzer Code style analyzer development
gometalint Reports gometalinter results on pull requests testing and demo
sonarcheck An analyzer that uses bblfsh UAST and sonar-checks to process pull requests testing and demo
terraform An analyzer that checks if Terraform files are correctly formatted usable

SDK for Analyzer Developers

If you are developing an Analyzer, please check the SDK documentation.

Development

Build

You can separately build the binaries provided by lookout; the binaries will be stored under build/bin directory.

server:

$ make build

lookout-sdk:

$ make -f Makefile.sdk build

dummy analyzer:

$ make -f Makefile.dummy build

Code generation

To generate go code from kallax models, run:

$ go generate ./...

To update go-bindata with the new migration files:

$ kallax migrate --input ./store/models/ --out ./store/migrations --name <name>
$ make dependencies
$ make bindata

Testing

For unit-tests run:

$ make test

For lookout-sdk integration tests (-short will skip tests that require bblfsh):

$ make test-sdk
$ make test-sdk-short

For lookoutd serve integration tests:

$ make test-json

Dummy Analyzer Release

Dummy analyzer is a simple analyzer implementation example. It is part of the lookout codebase but it's release cycle is managed independently from main one.

To release a new version and publish the dummy analyzer container you need to create a tag with the dummy prefix, e.g. dummy-v0.0.1. Please note this doesn't require to do a GitHub release, we just need the Git tag.

A normal release tag will not publish this container.

Contribute

Contributions are more than welcome, if you are interested please take a look at our Contributing Guidelines.

Code of Conduct

All activities under source{d} projects are governed by the source{d} code of conduct.

License

Affero GPL v3.0, see LICENSE.

Documentation

Overview

Package lookout provides gRPC APIs to implement analysis servers and clients.

Services

There are two services:

  1. Analyzer: analyzers process source code changes and provide analysis results as text comments, possibly linked to specific parts of the code.

2. Data: provides simple access to source code changes.

Index

Constants

This section is empty.

Variables

View Source 
var (
	// NoErrStopWatcher if a new error of this kind is returned by EventHandler
	// the Watcher.Watch function exits without error.
	NoErrStopWatcher = errors.NewKind("Stop watcher")
)

Functions

func RegisterAnalyzerServer 

func RegisterAnalyzerServer(s *grpc.Server, srv AnalyzerServer)

func RegisterDataServer 

func RegisterDataServer(s *grpc.Server, srv *DataServerHandler)

Types

type AnalysisStatus added in v0.0.3 

type AnalysisStatus int

AnalysisStatus is the status reported to the provider to inform that we are performing an analysis, or that it has finished 

const (

	// ErrorAnalysisStatus represents an error status
	ErrorAnalysisStatus AnalysisStatus
	// FailureAnalysisStatus represents a failure status
	FailureAnalysisStatus
	// PendingAnalysisStatus represents a pending status
	PendingAnalysisStatus
	// SuccessAnalysisStatus represents a success status
	SuccessAnalysisStatus
)

func (AnalysisStatus) String added in v0.0.3 

func (st AnalysisStatus) String() string

type Analyzer 

type Analyzer struct {
	Client AnalyzerClient
	Config AnalyzerConfig
}

Analyzer is a struct of analyzer client and config

type AnalyzerClient 

type AnalyzerClient = pb.AnalyzerClient

func NewAnalyzerClient 

func NewAnalyzerClient(conn *grpc.ClientConn) AnalyzerClient

type AnalyzerComments added in v0.0.4 

type AnalyzerComments struct {
	Config   AnalyzerConfig
	Comments []*Comment
}

AnalyzerComments contains a group of comments and the config for the analyzer that created them

type AnalyzerConfig 

type AnalyzerConfig struct {
	Name string
	// Addr is gRPC URL.
	// can be defined only in global config, repository-scoped configuration is ignored
	Addr string
	// Disabled repository-scoped configuration can accept only true value, false value is ignored
	Disabled bool
	// Feedback is a url to be linked after each comment
	Feedback string
	// Settings any configuration for an analyzer
	Settings map[string]interface{}
}

AnalyzerConfig is a configuration of analyzer

type AnalyzerServer 

type AnalyzerServer = pb.AnalyzerServer

type Change 

type Change = pb.Change

type ChangeGetter 

type ChangeGetter interface {
	// GetChanges returns a ChangeScanner that scans all changes according
	// to the request.
	GetChanges(context.Context, *ChangesRequest) (ChangeScanner, error)
}

ChangeGetter is used to retrieve code changes.

type ChangeScanner 

type ChangeScanner interface {
	// Next advances the scanner to the next change. It returns true if a new
	// change is found, and false otherwise. After the user is done scanning,
	// Err must be called to check if all changes were consumed or there was an
	// error.
	Next() bool
	// Err returns any error found during scanning.
	Err() error
	// Change returns the current change.
	Change() *Change
	// Close closes the scanner.
	Close() error
}

ChangeScanner is a scanner for changes.

type ChangesRequest 

type ChangesRequest = pb.ChangesRequest

type ClientChangeScanner 

type ClientChangeScanner struct {
	// contains filtered or unexported fields
}

func (*ClientChangeScanner) Change 

func (s *ClientChangeScanner) Change() *Change

func (*ClientChangeScanner) Close 

func (s *ClientChangeScanner) Close() error

func (*ClientChangeScanner) Err 

func (s *ClientChangeScanner) Err() error

func (*ClientChangeScanner) Next 

func (s *ClientChangeScanner) Next() bool

type ClientFileScanner 

type ClientFileScanner struct {
	// contains filtered or unexported fields
}

func (*ClientFileScanner) Close 

func (s *ClientFileScanner) Close() error

func (*ClientFileScanner) Err 

func (s *ClientFileScanner) Err() error

func (*ClientFileScanner) File 

func (s *ClientFileScanner) File() *File

func (*ClientFileScanner) Next 

func (s *ClientFileScanner) Next() bool

type Comment 

type Comment = pb.Comment

type CommitRevision 

type CommitRevision = pb.CommitRevision

type DataClient 

type DataClient struct {
	// contains filtered or unexported fields
}

func NewDataClient 

func NewDataClient(cc *grpc.ClientConn) *DataClient

func (*DataClient) GetChanges 

func (c *DataClient) GetChanges(ctx context.Context, in *ChangesRequest, opts ...grpc.CallOption) (
	ChangeScanner, error)

func (*DataClient) GetFiles 

func (c *DataClient) GetFiles(ctx context.Context, in *FilesRequest, opts ...grpc.CallOption) (
	FileScanner, error)

type DataServerHandler 

type DataServerHandler struct {
	ChangeGetter ChangeGetter
	FileGetter   FileGetter
}

func (*DataServerHandler) GetChanges 

func (s *DataServerHandler) GetChanges(req *ChangesRequest,
	srv pb.Data_GetChangesServer) (err error)

func (*DataServerHandler) GetFiles 

func (s *DataServerHandler) GetFiles(req *FilesRequest, srv pb.Data_GetFilesServer) (err error)

type Event 

type Event interface {
	// ID returns the EventID.
	ID() EventID
	// Type returns the EventType, in order to identify the concreate type of
	// the event.
	Type() EventType
	// Revision returns a commit revision, containing the head and the base of
	// the changes.
	Revision() *CommitRevision
	// Validate returns an error if the event is malformed
	Validate() error
}

Event represents a repository event.

type EventHandler 

type EventHandler func(context.Context, Event) error

EventHandler is the function to be called when a new event happens.

type EventID 

type EventID = pb.EventID

type EventResponse 

type EventResponse = pb.EventResponse

type EventType 

type EventType = pb.EventType

type File 

type File = pb.File

type FileGetter 

type FileGetter interface {
	// GetFiles returns a FilesScanner that scans all files according
	// to the request.
	GetFiles(context.Context, *FilesRequest) (FileScanner, error)
}

FileGetter is used to retrieve all code for a revision.

type FileScanner 

type FileScanner interface {
	// Next advances the scanner to the next file. It returns true if a new
	// file is found, and false otherwise. After the user is done scanning,
	// Err must be called to check if all files were consumed or there was an
	// error.
	Next() bool
	// Err returns any error found during scanning.
	Err() error
	// File returns the current file.
	File() *File
	// Close closes the scanner.
	Close() error
}

FileScanner is a scanner for files.

type FilesRequest 

type FilesRequest = pb.FilesRequest

type FnChangeScanner 

type FnChangeScanner struct {
	Scanner ChangeScanner
	Fn      func(*Change) (bool, error)
	OnStart func() error
	// contains filtered or unexported fields
}

FnChangeScanner implements ChangeScanner using functions

func (*FnChangeScanner) Change 

func (s *FnChangeScanner) Change() *Change

func (*FnChangeScanner) Close 

func (s *FnChangeScanner) Close() error

func (*FnChangeScanner) Err 

func (s *FnChangeScanner) Err() error

func (*FnChangeScanner) Next 

func (s *FnChangeScanner) Next() bool

type FnFileScanner 

type FnFileScanner struct {
	Scanner FileScanner
	Fn      func(*File) (bool, error)
	OnStart func() error
	// contains filtered or unexported fields
}

FnFileScanner implements FileScanner using functions

func (*FnFileScanner) Close 

func (s *FnFileScanner) Close() error

func (*FnFileScanner) Err 

func (s *FnFileScanner) Err() error

func (*FnFileScanner) File 

func (s *FnFileScanner) File() *File

func (*FnFileScanner) Next 

func (s *FnFileScanner) Next() bool

type Poster 

type Poster interface {
	// Post posts comments about an event.
	Post(context.Context, Event, []AnalyzerComments) error

	// Status sends the current analysis status to the provider
	Status(context.Context, Event, AnalysisStatus) error
}

Poster can post comments about an event.

type PushEvent 

type PushEvent = pb.PushEvent

type ReferencePointer 

type ReferencePointer = pb.ReferencePointer

type RepositoryInfo 

type RepositoryInfo = pb.RepositoryInfo

type ReviewEvent 

type ReviewEvent = pb.ReviewEvent

type Watcher 

type Watcher interface {
	// Watch for new events triggering the EventHandler for each new issue,
	// it stops until an error is returned by the EventHandler. Network errors
	// or other temporal errors are handled as non-fatal errors, just logging it.
	Watch(context.Context, EventHandler) error
}

Watcher watch for new events in given provider.

Source Files

View all Source files

Directories

Path Synopsis
cmd
dummy
lookout-sdk
lookoutd
Package dummy implements an example analyzer.
 Package dummy implements an example analyzer.
provider
github
json
service
bblfsh
Package bblfsh provides access to bblfsh parsing for the data service.
 Package bblfsh provides access to bblfsh parsing for the data service.
enry
git
Package git provides access to git repositories.
 Package git provides access to git repositories.
purge
models
Code generated by https://github.com/src-d/go-kallax.
 Code generated by https://github.com/src-d/go-kallax.
util
cache
cli
cmdtest
ctxlog
grpchelper

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.