package gogs

import (
	"github.com/drone/config"
	"github.com/drone/drone/plugin/remote"
)

var (
	gogsUrl    = config.String("gogs-url", "")
	gogsSecret = config.String("gogs-secret", "")
)

// Registers the Gogs plugin using the default
// settings from the config file or environment
// variables.
func Register() {
	if len(*gogsUrl) == 0 {
		return
	}
	remote.Register(
		New(*gogsUrl, *gogsSecret),
	)
}

package bitbucket

import (
	"github.com/drone/config"
	"github.com/quartethealth/drone/plugin/remote"
)

var (
	// Bitbucket cloud configuration details
	bitbucketClient = config.String("bitbucket-client", "")
	bitbucketSecret = config.String("bitbucket-secret", "")
	bitbucketOpen   = config.Bool("bitbucket-open", false)
)

// Registers the Bitbucket plugin using the default
// settings from the config file or environment
// variables.
func Register() {
	if len(*bitbucketClient) == 0 || len(*bitbucketSecret) == 0 {
		return
	}
	remote.Register(
		NewDefault(*bitbucketClient, *bitbucketSecret, *bitbucketOpen),
	)
}

const (
	DockerTLSWarning = `WARINING: Docker TLS cert or key not given, this may cause a build errors`
)

var (
	// commit sha for the current build, set by
	// the compile process.
	version  string = "0.3-dev"
	revision string
)

var (
	// Database driver configuration. Defaults to sqlite
	// when no database configuration specified.
	datasource = config.String("database-datasource", "drone.sqlite")
	driver     = config.String("database-driver", "sqlite3")

	// HTTP Server settings.
	port   = config.String("server-port", ":8000")
	sslcrt = config.String("server-ssl-cert", "")
	sslkey = config.String("server-ssl-key", "")

	// Enable self-registration. When false, the system admin
	// must grant user access.
	open = config.Bool("registration-open", false)

	workers *pool.Pool
	worker  *director.Director
	pub     *pubsub.PubSub

package github

import (
	"github.com/drone/config"
	"github.com/drone/drone/plugin/remote"
)

var (
	// GitHub cloud configuration details
	githubClient = config.String("github-client", "")
	githubSecret = config.String("github-secret", "")

	// GitHub Enterprise configuration details
	githubEnterpriseURL     = config.String("github-enterprise-url", "")
	githubEnterpriseAPI     = config.String("github-enterprise-api", "")
	githubEnterpriseClient  = config.String("github-enterprise-client", "")
	githubEnterpriseSecret  = config.String("github-enterprise-secret", "")
	githubEnterprisePrivate = config.Bool("github-enterprise-private-mode", true)
)

// Registers the GitHub plugins using the default
// settings from the config file or environment
// variables.
func Register() {
	registerGitHub()
	registerGitHubEnterprise()
}

// registers the GitHub (github.com) plugin
func registerGitHub() {
	if len(*githubClient) == 0 || len(*githubSecret) == 0 {

	"code.google.com/p/go.net/context"
	"github.com/armab/drone/server/datastore"
	"github.com/armab/drone/shared/httputil"
	"github.com/armab/drone/shared/model"
	"github.com/dgrijalva/jwt-go"
	"github.com/drone/config"
	"github.com/gorilla/securecookie"
)

// random key used to create jwt if none
// provided in the configuration.
var random = securecookie.GenerateRandomKey(32)

var (
	secret  = config.String("session-secret", string(random))
	expires = config.Duration("session-expires", time.Hour*72)
)

// GetUser gets the currently authenticated user for the
// http.Request. The user details will be stored as either
// a simple API token or JWT bearer token.
func GetUser(c context.Context, r *http.Request) *model.User {
	switch {
	case r.Header.Get("Authorization") != "":
		return getUserBearer(c, r)
	case r.FormValue("access_token") != "":
		return getUserToken(c, r)
	default:
		return nil
	}

const rsaKeyPrefix = "-----BEGIN RSA PRIVATE KEY-----"

func formatRsaKey(key string) string {
	// If this came from the config file it should be formatted right
	if !strings.HasPrefix(key, rsaKeyPrefix) {
		// Replace spaces in the key with newlines. This makes it
		// easier to pass the key in an environment variable
		key = strings.Replace(key, " ", "\n", -1)
		key = fmt.Sprintf("%s\n%s\n-----END RSA PRIVATE KEY-----", rsaKeyPrefix, key)
	}

	return key
}

var (
	googleServiceEmail      = config.String("google-service-email", "")
	googleServicePrivateKey = config.String("google-service-private-key", "")
	googleServiceUser       = config.String("google-service-user", "")
)

// InitializeGoogleGroup checks that our Google service account is able to fetch
// group membership for a user (It users the `google-service-user` to test).
func InitializeGoogleGroup() error {
	*googleServicePrivateKey = formatRsaKey(*googleServicePrivateKey)

	groups, err := GetUserGroups(*googleServiceUser)
	if err != nil {
		return fmt.Errorf("Google groups doesn't work: %s", err)
	}
	fmt.Printf("google groups test: passed (user %s is a member of %#v)\n",
		*googleServiceUser, groups)

package gitlab

import (
	"github.com/drone/config"
	"github.com/drone/drone/plugin/remote"
)

var (
	gitlabURL        = config.String("gitlab-url", "")
	gitlabSkipVerify = config.Bool("gitlab-skip-verify", false)
	gitlabOpen       = config.Bool("gitlab-open", false)

	gitlabClient = config.String("gitlab-client", "")
	gitlabSecret = config.String("gitlab-secret", "")
)

// Registers the Gitlab plugin using the default
// settings from the config file or environment
// variables.
func Register() {
	if len(*gitlabURL) == 0 {
		return
	}
	remote.Register(
		New(
			*gitlabURL,
			*gitlabSkipVerify,
			*gitlabOpen,
			*gitlabClient,
			*gitlabSecret,
		),

	npm publish %s
	[ -n ${_NPM_PACKAGE_TAG} ] && npm tag ${_NPM_PACKAGE_NAME} ${_NPM_PACKAGE_TAG}
else
	echo "skipping publish, package ${_NPM_PACKAGE_NAME} already published"
fi
unset _NPM_PACKAGE_NAME
unset _NPM_PACKAGE_TAG
`

const (
	CmdAlwaysAuth  = "npm set always-auth true"
	CmdSetRegistry = "npm config set registry %s"
)

var (
	DefaultUser  = config.String("npm-user", "")
	DefaultPass  = config.String("npm-pass", "")
	DefaultEmail = config.String("npm-email", "")
)

type NPM struct {
	// The Email address used by NPM to connect
	// and publish to a repository
	Email string `yaml:"email,omitempty"`

	// The Username used by NPM to connect
	// and publish to a repository
	Username string `yaml:"username,omitempty"`

	// The Password used by NPM to connect
	// and publish to a repository

	NotifyNever  = "never"  // never send email notifications
	NotifyAuthor = "author" // only send email notifications to the author

	NotifyTrue  = "true"  // alias for NotifyTrue
	NotifyFalse = "false" // alias for NotifyFalse
	NotifyOn    = "on"    // alias for NotifyTrue
	NotifyOff   = "off"   // alias for NotifyFalse
	NotifyBlame = "blame" // alias for NotifyAuthor
)

const (
	Subject = "[%s] %s/%s (%s - %s)"
)

var (
	DefaultHost = config.String("smtp-host", "")
	DefaultPort = config.String("smtp-port", "")
	DefaultFrom = config.String("smtp-from", "")
	DefaultUser = config.String("smtp-user", "")
	DefaultPass = config.String("smtp-pass", "")
)

type Email struct {
	Recipients []string `yaml:"recipients"`
	Success    string   `yaml:"on_success"`
	Failure    string   `yaml:"on_failure"`

	Host     string `yaml:"host"`
	Port     string `yaml:"port"`
	From     string `yaml:"from"`
	Username string `yaml:"username"`

package stash

import (
	"github.com/drone/config"
	"github.com/drone/drone/plugin/remote"
)

var (
	// Stash configuration details
	stashURL        = config.String("stash-url", "")
	stashAPI        = config.String("stash-api", "")
	stashSecret     = config.String("stash-secret", "")
	stashPrivateKey = config.String("stash-private-key", "")
	stashHook       = config.String("stash-hook", "")
	stashOpen       = config.Bool("stash-open", false)
)

// Registers the Stash plugin using the default
// settings from the config file or environment
// variables
func Register() {
	if len(*stashURL) == 0 ||
		len(*stashAPI) == 0 ||
		len(*stashSecret) == 0 ||
		len(*stashPrivateKey) == 0 ||
		len(*stashHook) == 0 {
		return
	}
	remote.Register(
		New(
			*stashURL,

_NPM_PACKAGE_NAME=$(cd %s && npm list | head -n 1 | cut -d ' ' -f1)
_NPM_PACKAGE_TAG="%s"
_EXISTING_NPM_PKG=$(npm info ${_NPM_PACKAGE_NAME} 2> /dev/null || true)
if [ "${_EXISTING_NPM_PKG}" = "" ] || [ "${_EXISTING_NPM_PKG}" = "undefined" ]
then
	npm publish %s
else
	echo "skipping publish, package ${_NPM_PACKAGE_NAME} already published"
fi
unset _NPM_PACKAGE_NAME
unset _NPM_PACKAGE_TAG
unset _EXISTING_NPM_PKG
`

var (
	DefaultToken    = config.String("npm-token", "")
	DefaultRegistry = config.String("npm-registry", "registry.npmjs.org")
)

type NPM struct {
	// The Token used by NPM to connect
	// and publish to a repository
	Token string `yaml:"token,omitempty"`

	// The registry URL of custom npm repository
	Registry string `yaml:"registry,omitempty"`

	// A folder containing the package.json file
	Folder string `yaml:"folder,omitempty"`

	// Registers the published package with the given tag

	//"strings"

	"github.com/drone/config"

	"github.com/tuanp/autoapi/middleware"
	"github.com/tuanp/autoapi/router"
	"github.com/tuanp/autoapi/system"
	"github.com/tuanp/autoapi/util/log"

	//"github.com/RainingClouds/yaag/yaag"

	gojiMiddleware "github.com/zenazn/goji/web/middleware"
)

var (
	databaseUrl      = config.String("database-url", "mongodb://pat109:[email protected]:41160/voa")
	databaseName     = config.String("database-name", "voa")
	databaseUsername = config.String("database-username", "drone.sqlite")
	databasePassword = config.String("database-password", "drone.sqlite")

	// HTTP Server settings.
	port   = config.String("server-port", ":8000")
	sslcrt = config.String("server-ssl-cert", "")
	sslkey = config.String("server-ssl-key", "")
)

func main() {
	log.SetPriority(log.LOG_NOTICE)

	var conf string
	flag.StringVar(&conf, "config", "", "")

	"github.com/armab/drone/plugin/remote/github/oauth"
	"github.com/armab/drone/shared/httputil"
	"github.com/armab/drone/shared/model"
	"github.com/drone/config"
	"github.com/drone/go-github/github"
)

const (
	DefaultAPI   = "https://api.github.com/"
	DefaultURL   = "https://github.com"
	DefaultScope = "repo,repo:status,user:email"
)

var (
	BuildConfigFile = config.String("server-file", ".drone.yml")
)

type GitHub struct {
	URL        string
	API        string
	Client     string
	Secret     string
	Private    bool
	SkipVerify bool
	Orgs       []string
	Open       bool
}

func New(url, api, client, secret string, private, skipVerify bool, orgs []string, open bool) *GitHub {
	var github = GitHub{

package awsconsoleauth

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"time"

	"github.com/dgrijalva/jwt-go"
	"github.com/drone/config"
	"golang.org/x/oauth2"
	"golang.org/x/oauth2/google"
)

var googleClientID = config.String("google-client-id", "")
var googleClientSecret = config.String("google-client-secret", "")
var googleDomain = config.String("google-domain", "")

var googleOauthConfig = &oauth2.Config{
	Scopes:   []string{"email"},
	Endpoint: google.Endpoint,
}

var googleJWTSigningKeys = map[string]interface{}{}

func updateGoogleJWTSigningKeys() error {
	// Fetch the google keys for oauth
	googleCertsResponse, err := http.Get("https://www.googleapis.com/oauth2/v1/certs")
	if err != nil {
		return err

package awsconsoleauth

import (
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"strings"
	"time"

	"github.com/crowdmob/goamz/aws"
	"github.com/crowdmob/goamz/sts"
	"github.com/drone/config"
)

var awsRegion = config.String("aws-region", "")

var awsAccessKey = config.String("aws-access-key-id", "")
var awsSecretKey = config.String("aws-secret-access-key", "")

var awsAuth aws.Auth

// InitializeAWS sets up access to the AWS Simple Token Service
func InitializeAWS() error {
	if *awsRegion == "" {
		*awsRegion = aws.InstanceRegion()
		if *awsRegion == "unknown" {
			*awsRegion = "us-east-1"
		}
	}