@@ -23,7 +23,7 @@ func main() {

 	}

 	basename := filepath.Base(os.Args[0])

-	command := gitserver.NewCommandGitServer(basename)

+	command := gitserver.CommandFor(basename)

 	if err := command.Execute(); err != nil {

 		os.Exit(1)

 	}

@@ -7,7 +7,12 @@ FROM openshift/origin

 ADD bin/gitserver /usr/bin/gitserver

 ADD hooks/ /var/lib/git-hooks/

-RUN mkdir -p /var/lib/git

+RUN mkdir -p /var/lib/git && \

+    mkdir -p /var/lib/gitconfig && \

+    chmod 777 /var/lib/gitconfig && \

+    ln -s /usr/bin/gitserver /usr/bin/gitrepo-buildconfigs

+ADD gitconfig /var/lib/gitconfig/.gitconfig

+ENV HOME=/var/lib/gitconfig

 VOLUME /var/lib/git

 ENTRYPOINT ["/usr/bin/gitserver"]

@@ -1,16 +1,214 @@

 Configurable Git Server

 =======================

-This example provides automatic mirroring of Git repositories, intended

-for use within a container or Kubernetes pod. It can clone repositories

-from remote systems on startup as well as remotely register hooks. It

-can automatically initialize and receive Git directories on push.

-

-In the more advanced modes, it can integrate with an OpenShift server to

-automatically perform actions when new repositories are created, like

-reading the build configs in the current namespace and performing

-automatic mirroring of their input, and creating new build-configs when

-content is pushed.

-

-The Dockerfile built by this example is published as

-openshift/origin-gitserver

\ No newline at end of file

+Overview

+--------

+

+This example git server is intended for use within a container or Kubernetes pod.

+It can clone repositories from remote systems on startup as well as automatically

+launch builds in an OpenShift project. It can automatically initialize and receive

+Git directories on push.

+

+Hooks can be customized to perform actions on push such as invoking `oc new-app` on a

+repository's source.

+

+The Dockerfile built by this example is published as openshift/origin-gitserver

+

+Quick Start

+-----------

+

+Prerequisites:

+

+* You have an OpenShift v3 server running

+* You are logged in and have access to a project

+* You have the `gitserver.yaml` from this directory

+* You can create externally accessible routes on your server

+

+### Deploy the Git Server

+

+1. Create the Git Server

+

+    ```sh

+    $ oc create -f gitserver.yaml

+    ```

+

+2. Grant `edit` access to the `git` service account

+

+    ```sh

+    $ oc policy add-role-to-user edit -z git

+    ```

+

+

+### Push code to the Git Server

+

+Code repositories can be initialized on the Git Server by either doing a 'git push' or

+a 'git clone' of the repository.

+

+

+1. Find your git server's URL

+

+   If you have a working router, determine the host name of your git server by getting its route:

+

+   ```sh

+   $ oc get route git

+   ```

+

+   In this case, the URL of your git server will be the host name used by the route; something like: 

+   

+   ```

+   http://git-myproject.infra.openshift.com

+   ```

+  

+   Alternatively, if your router is not functional, you can port-forward the git-server pod to your local machine.

+   In a separate shell window, execute the following: (You must leave the port-forward command running

+   for the port to be forwarded to your machine)

+

+   ```

+   $ oc get pods | grep git           ## get the git server pod

+   $ oc port-forward -p PODNAME 8080  ## start port-forward where PODNAME is the git server pod

+   ```

+

+   In this case, the URL of your git server will be your local host:

+

+   ```

+   http://localhost:8080

+   ```

+

+

+2. Setup your credentials

+

+   By default the Git Server will allow users or service accounts that can create pods in

+   the project namespace to create and push code to the Git Server. The easiest way to 

+   provide credentials to the Git Server is by using a custom credential helper that will 

+   send your OpenShift token by default to the server.

+   ```sh

+   $ git config --global credential.http://gitserver-myproject.infra.openshift.com.helper \

+         '!f() { echo "username=$(oc whoami)"; echo "password=$(oc whoami -t)"; }; f'

+   ```

+

+   **NOTE:** the config key is `credential.[git server URL].helper`

+

+3. Push a repository to your git server

+

+   In an existing repository, add a remote that points to the git server and push to it

+   

+   ```

+   # clone a public repository

+   $ git clone https://github.com/openshift/ruby-hello-world.git

+

+   # add a remote for your git server

+   $ cd ruby-hello-world

+   $ git remote add openshift http://git-myproject.infra.openshift.com/ruby-hello-world.git  

+

+   # push the code to the git server

+   $ git push openshift master

+   ```

+

+   **NOTE:** the ruby-hello-world.git repository does not exist before running these commands. 

+   By pushing to it, you are creating it in the Git Server.

+

+   On push the git server will invoke new-app on the code and create artifacts for it in 

+   OpenShift.

+

+

+### Secure the Git Server

+

+Beyond demo uses, it is recommended that communication with the Git server be encrypted with the TLS

+protocol to avoid transmission of source in plain text.

+

+1. Modify your route to use edge termination:

+

+   ```sh

+   $ oc edit route git

+   ```

+

+   Add tls -> termination -> edge to the route specification:

+

+   ```yaml

+   apiVersion: v1

+   kind: Route

+   metadata:

+     name: gitserver

+   spec:

+     host: gitserver-myproject.infra.openshift.com

+     tls:

+       termination: edge

+     to:

+       kind: Service

+       name: gitserver

+   ```

+

+2. If using a private certificate authority, configure your git client to use the private ca.crt file:

+

+   ```sh

+   $ git config --global http.https://gitserver-myproject.infra.openshift.com.sslCAInfo /path/to/ca.crt

+   ```

+

+   where the key is http.[git server URL].sslCAInfo

+

+3. Disable anonymous cloning. By default the gitserver will allow anonymous cloning to make it easier to 

+   run builds without having to specify a secret. You can disable this by setting the `ALLOW_ANON_GIT_PULL`

+   environment variable to `false`.

+

+   ```sh

+   $ oc set env dc/git ALLOW_ANON_GIT_PULL=false

+   ```

+

+   **NOTE:** changing environment variables on the git server will cause a redeploy of the git server. If using

+   the default ephemeral storage for it, all repositories that have been pushed previously will be wiped out.

+   They will need to be pushed to the server again to restore.

+

+Authentication

+--------------

+

+By default, the gitserver will authenticate using OpenShift user or service account credentials. For a user,

+the credentials are the user name, and the user's token (from `oc whoami -t`). For a service account, the user

+name is the service account name and the password is the service account token. The token can

+be one of the 2 tokens created with the service account and stored in the service account secrets. These can 

+be obtained by looking at the secrets that correspond to the service account (`oc get secrets`) and displaying

+the token in one of them: `oc describe secret NAME`.

+

+

+Authorization

+-------------

+

+Users or service accounts must be able to read pods in the current namespace in order to fetch repositories from

+the Git Server. Specifying ALLOW_ANON_GIT_PULL=true as an environment variable for the Git Server will allow anyone

+to fetch/clone content from the Git Server. To create/push content, users or service accounts must have the right 

+to create pods in the namespace.

+

+

+Automatically Cloning Public Repositories

+-----------------------------------------

+

+The Git Server can automatically clone a set of repositories on startup if it is going to be used for mirroring

+purposes. Repositories to be cloned can be specified using a set of environment variables that match

+`GIT_INITIAL_CLONE_[name]` where [name] must be unique. The value of the variable must be a URL to the remote

+repository to clone and an optional name for the clone.

+

+The following command will add an environment variable to clone the openshift/ruby-hello-world repository and give

+it a name of `helloworld` inside the Git Server.

+

+```sh

+$ oc set env dc/gitserver GIT_INITIAL_CLONE_1="https://github.com/openshift/ruby-hello-world.git;helloworld"

+```

+

+Automatically Starting Builds

+-----------------------------

+

+By default, whenever the git server receives a commit, it will look for a BuildConfig in the same namespace as the

+git server and the same name as the repository where the commit is being pushed.  If it finds a BuildConfig with 

+the same name, it will start a build for that BuildConfig. Alternatively, an annotation may be added to a 

+BuildConfig to explicitly link it to a repository on the git server:

+

+```yaml

+apiVersion: v1

+kind: BuildConfig

+metadata:

+  annotations:

+      openshift.io/git-repository: myrepo

+```

+

+**NOTE**: A build will be started for the BuildConfig matching the name of the repository and for any BuildConfig 

+that has an annotation pointing to the source repository. If there is a BuildConfig that has a matching name but

+has an annotation pointing to a different repository, a build will not be invoked for it.

new file mode 100644

@@ -0,0 +1,5 @@

+[url "http://127.0.0.1"]

+   insteadOf = http://git

+[user]

+   email = dev@openshift

+   name = Development

@@ -2,28 +2,28 @@ apiVersion: v1

 kind: List

 items:

-# The gitserver is deployed as a singleton pod and uses a very small amount

+# The git server is deployed as a singleton pod and uses a very small amount

 # of resources. It can host or transiently serve Git repositories, as well

 # as automatically integrate with builds in a namespace.

 - apiVersion: v1

   kind: DeploymentConfig

   metadata:

-    name: gitserver

+    name: git

     labels:

-      app: gitserver

+      app: git

   spec:

-    replicas: 1 # the gitserver is not HA and should not be scaled past 1

+    replicas: 1 # the git server is not HA and should not be scaled past 1

     selector:

-      run-container: gitserver

+      run-container: git

     template:

       metadata:

         labels:

-          run-container: gitserver

+          run-container: git

       spec:

-        serviceAccountName: gitserver

+        serviceAccountName: git

         containers:

-        - name: gitserver

-          image: openshift/origin-gitserver

+        - name: git

+          image: openshift/origin-gitserver:latest

           ports:

           - containerPort: 8080

@@ -51,7 +51,13 @@ items:

           # stored in this app.

           # TOOD: support HTTPS

           - name: PUBLIC_URL

-            value: http://gitserver.$(POD_NAMESPACE).svc.cluster.local:8080

+            value: http://git.$(POD_NAMESPACE).svc.cluster.local:8080

+          # If INTERNAL_URL is specified, then it's used to point

+          # BuildConfigs to the internal service address of the git

+          # server

+          - name: INTERNAL_URL

+            value: http://git:8080

+

           # The directory to store Git repositories in. If not backed

           # by a persistent volume, repositories will be lost when

           # deployments occur. Use INITIAL_GIT_CLONE and AUTOLINK_*

@@ -62,26 +68,39 @@ items:

           # The directory to use as the default hook directory for any

           # cloned or autolinked directories.

           - name: HOOK_PATH

-          # value: /var/lib/git-hooks

+            value: /var/lib/git-hooks

+

+          # If 'true' new-app will be invoked on push for repositories

+          # for which a matching BuildConfig is not found.

+          - name: GENERATE_ARTIFACTS

+            value: "true"

+

+          # The script to use for custom language detection on a

+          # repository. See hooks/detect-language for an example.

+          # To use new-app's default detection, leave this variable

+          # blank.

+          - name: DETECTION_SCRIPT

+          # value: detect-language

           # Authentication and authorization

-          # If 'yes', clients may push to the server with git push.

+          # If 'true', clients may push to the server with git push.

           - name: ALLOW_GIT_PUSH

-            value: "yes"

-          # If 'yes', clients may set hooks via the API. However, unless

+            value: "true"

+          # If 'true', clients may set hooks via the API. However, unless

           # the Git home is backed by a persistent volume, any deployment

           # will result in the hooks being lost.

           - name: ALLOW_GIT_HOOKS

-            value: "yes"

-          # If 'yes', clients can create new git repositories on demand

+            value: "true"

+          # If 'true', clients can create new git repositories on demand

           # by pushing. If the data on disk is not backed by a persistent

           # volume, the Git repo will be deleted if the deployment is

           # updated.

           - name: ALLOW_LAZY_CREATE

-            value: "yes"

-          # If 'yes', clients can pull without being authenticated.

+            value: "true"

+          # If 'true', clients can pull without being authenticated.

           - name: ALLOW_ANON_GIT_PULL

+            value: "true"

           # Provides the path to a kubeconfig file in the image that

           # should be used to authorize against the server. The value

@@ -102,7 +121,7 @@ items:

           # Autolinking:

           #

-          # The gitserver can automatically clone Git repositories

+          # The git server can automatically clone Git repositories

           # associated with a build config and replace the URL with

           # a link to the repo on PUBLIC_URL. The default post-receive

           # hook on the cloned repo will then trigger a build. You

@@ -110,8 +129,7 @@ items:

           # To autolink, the account the pod runs under must have 'edit'

           # on the AUTOLINK_NAMESPACE:

           #

-          #    oc policy add-role-to-user \

-          #      system:serviceaccount:${namespace}:gitserver edit

+          #    oc policy add-role-to-user -z git edit

           #

           # Links are checked every time the pod starts.

@@ -132,12 +150,6 @@ items:

           # image for examples.

           - name: AUTOLINK_HOOK

-          # The master service host is not signed with the service IP

-          # so we override with the consistent DNS name. Required for

-          # connections to the server.

-          - name: KUBERNETES_SERVICE_HOST

-            value: kubernetes.default

-

           volumeMounts:

           - mountPath: /var/lib/git/

             name: git

@@ -147,25 +159,36 @@ items:

     triggers:

     - type: ConfigChange

-# The gitserver service is required for DNS resolution

+# The git server service is required for DNS resolution

 - apiVersion: v1

   kind: Service

   metadata:

-    name: gitserver

+    name: git

     labels:

-      app: gitserver

+      app: git

   spec:

     ports:

     - port: 8080

       targetPort: 8080

     selector:

-      run-container: gitserver

+      run-container: git

-# The service account for the gitserver must be granted the edit role if

-# you wish to use autolinking.

+# The service account for the git server must be granted the view role to

+# automatically start builds, edit role to create objects and autolink

 - apiVersion: v1

   kind: ServiceAccount

   metadata:

-    name: gitserver

+    name: git

     labels:

-      app: gitserver

+      app: git

+

+# Default route for git service

+- apiVersion: v1

+  kind: Route

+  metadata:

+    labels:

+      app: git

+    name: git

+  spec:

+    to:

+      name: git

@@ -20,13 +20,13 @@ function key {

 prefix=${PREFIX:-openshift/}

-if has Gemfile; then

+if has Gemfile Rakefile config.ru; then

   echo "${prefix}ruby"

   exit 0

 fi

-if has requirements.txt; then

-  echo "${prefix}python"

+if has pom.xml; then

+  echo "${prefix}wildfly"

   exit 0

 fi

@@ -35,14 +35,19 @@ if has package.json app.json; then

   exit 0

 fi

-if has '*.go'; then

-  echo "${prefix}golang"

+if has index.php composer.json; then

+  echo "${prefix}php"

   exit 0

 fi

-if has index.php; then

-  echo "${prefix}php"

+if has requirements.txt setup.py; then

+  echo "${prefix}python"

+  exit 0

+fi

+

+if has index.pl cpanfile; then

+  echo "${prefix}perl"

   exit 0

 fi

-exit 1

\ No newline at end of file

+exit 1

@@ -7,48 +7,77 @@ set -o pipefail

 function key {

   git config --local --get "${1}"

 }

+

 function addkey {

   git config --local --add "${1}" "${2}"

 }

 function detect {

-  if detected=$(key openshift.io.detect); then

-    exit 0

-  fi

-  if ! url=$(key gitserver.self.url); then

-    echo "detect: no self url set"

-    exit 0

+  local repoURL="$1"

+  local repoName="$2"

+  local detectionScript=${DETECTION_SCRIPT:-}

+  # The purpose of using a custom detection script is that users can customize the 

+  # 'detect-language' script to return the image that's appropriate for their needs. 

+  # It is possible to just have new-app do code detection. In that case, just set

+  # the DETECTION_SCRIPT variable to an empty string.

+  if [[ -z $detectionScript ]]; then

+    oc new-app "${repoURL}"

+  else

+    if ! lang=$($(dirname $0)/${detectionScript}); then

+      return

+    fi

+    echo "detect: found language ${lang} for ${repoName}"

+    oc new-app "${lang}~${repoURL}"

   fi

+  # TODO: when a command to set a secret is available,

+  # set an optional secret on the resulting build configuration

+}

-  # TODO: make it easier to find the build config name created

-  # by oc new-app

-  name=$(basename "${url}")

-  name="${name%.*}"

+# If the 'oc' command is not found, exit

+if ! oc=$(which oc); then

+  echo "detect: oc is not installed"

+  exit 0

+fi

-  if ! lang=$($(dirname $0)/detect-language); then

-    exit 0

-  fi

-  echo "detect: found language ${lang} for ${name}"

+# If the current repository has no self.url, exit

+if ! url=$(key gitserver.self.url); then

+  echo "post-receive: no self url set"

+  exit 0

+fi

-  if ! oc=$(which oc); then

-    echo "detect: oc is not installed"

-    addkey openshift.io.detect 1

-    exit 0

-  fi

-  oc new-app "${lang}~${url}"

-  if webhook=$(oc start-build --list-webhooks="generic" "${name}" | head -n 1); then

-    addkey openshift.io.webhook "${webhook}"

-  fi

-  addkey openshift.io.detect 1

-}

+# Save received commits to a temporary file

+commits=$(mktemp)

+cat > ${commits}

-cat > /tmp/postreceived

+# Extract the name of the repository from the URL

+name=$(basename "${url}")

+name="${name%.*}"

-detect

+foundbc=false

+# Loop through build configurations that match this git repository

+while read bc ref

+do

+  foundbc=true

+  # If a generic webhook exists on the build config, determine if one of the received

+  # commits affects the reference in the build configuration

+  if webhook=$(oc start-build --list-webhooks="generic" "${bc}" | head -n 1); then

+    # Loop through the commits received by the hook. If the build configuration's git ref is an

+    # ancestor for the received commit, then start a new build for it.

+    while read old_commit new_commit ref_name

+    do

+      if $(git merge-base --is-ancestor "${ref}" "${new_commit}"); then

+        oc start-build --from-webhook="${webhook}" && echo "build: started on build configuration '${bc}'"

+        break

+      fi

+    done < "${commits}"

+  fi

+done < <(gitrepo-buildconfigs "${name}")

+

+if $foundbc; then

+  exit 0

+fi

-if webhook=$(key openshift.io.webhook); then

-  # TODO: print output from the server about the hook status

-  oc start-build --from-webhook="${webhook}"

-  # TODO: follow logs

-  echo "build: started"

+generate_artifacts=${GENERATE_ARTIFACTS:-}

+if [ "${generate_artifacts}" == "true" ]; then

+  detect "$url" "$name"

 fi

deleted file mode 100644

@@ -1,23 +0,0 @@

-package main

-

-import (

-	"fmt"

-	"log"

-	"os"

-

-	"github.com/openshift/origin/pkg/gitserver"

-)

-

-func main() {

-	if len(os.Args) != 1 {

-		fmt.Printf(`git-server - Expose Git repositories to the network

-

-%[1]s`, gitserver.EnvironmentHelp)

-		os.Exit(0)

-	}

-	config, err := gitserver.NewEnviromentConfig()

-	if err != nil {

-		log.Fatal(err)

-	}

-	log.Fatal(gitserver.Start(config))

-}

@@ -1,9 +1,12 @@

 package gitserver

 import (

+	"flag"

 	"fmt"

+	"io"

 	"log"

 	"net/url"

+	"os"

 	"github.com/spf13/cobra"

 	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"

@@ -20,6 +23,30 @@ and automatic creation of applications on push.

 %[1]s

 `

+const LogLevelEnv = "LOGLEVEL"

+const repositoryBuildConfigsDesc = `

+Retrieve build configs for a gitserver repository

+

+This command lists build configurations in the current namespace that correspond to a given git repository.

+`

+

+// CommandFor returns the appropriate command for this base name,

+// or the global OpenShift command

+func CommandFor(basename string) *cobra.Command {

+	var cmd *cobra.Command

+

+	out := os.Stdout

+

+	setLogLevel()

+

+	switch basename {

+	case "gitrepo-buildconfigs":

+		cmd = NewCommandRepositoryBuildConfigs(basename, out)

+	default:

+		cmd = NewCommandGitServer("gitserver")

+	}

+	return cmd

+}

 // NewCommandGitServer launches a Git server

 func NewCommandGitServer(name string) *cobra.Command {

@@ -59,3 +86,30 @@ func RunGitServer() error {

 	}

 	return gitserver.Start(config)

 }

+

+func NewCommandRepositoryBuildConfigs(name string, out io.Writer) *cobra.Command {

+	cmd := &cobra.Command{

+		Use:   fmt.Sprintf("%s REPOSITORY_NAME", name),

+		Short: "Retrieve build configs for a gitserver repository",

+		Long:  repositoryBuildConfigsDesc,

+		Run: func(c *cobra.Command, args []string) {

+			if len(args) != 1 {

+				err := cmdutil.UsageError(c, "This command takes a single argument - the name of the repository")

+				cmdutil.CheckErr(err)

+			}

+			repoName := args[0]

+			err := gitserver.GetRepositoryBuildConfigs(repoName, out)

+			cmdutil.CheckErr(err)

+		},

+	}

+	return cmd

+}

+

+func setLogLevel() {

+	logLevel := os.Getenv(LogLevelEnv)

+	if len(logLevel) > 0 {

+		if flag.CommandLine.Lookup("v") != nil {

+			flag.CommandLine.Set("v", logLevel)

+		}

+	}

+}

new file mode 100644

@@ -0,0 +1,68 @@

+package gitserver

+

+import (

+	"fmt"

+	"io"

+	"os"

+

+	kapi "k8s.io/kubernetes/pkg/api"

+	"k8s.io/kubernetes/pkg/client/restclient"

+

+	buildapi "github.com/openshift/origin/pkg/build/api"

+	"github.com/openshift/origin/pkg/client"

+)

+

+const gitRepositoryAnnotationKey = "openshift.io/git-repository"

+

+func GetRepositoryBuildConfigs(name string, out io.Writer) error {

+	client, err := getClient()

+	if err != nil {

+		return err

+	}

+

+	ns := os.Getenv("POD_NAMESPACE")

+	buildConfigList, err := client.BuildConfigs(ns).List(kapi.ListOptions{})

+	if err != nil {

+		return err

+	}

+

+	matchingBuildConfigs := []*buildapi.BuildConfig{}

+

+	for _, bc := range buildConfigList.Items {

+		repoAnnotation, hasAnnotation := bc.Annotations[gitRepositoryAnnotationKey]

+		if hasAnnotation {

+			if repoAnnotation == name {

+				matchingBuildConfigs = append(matchingBuildConfigs, &bc)

+			}

+			continue

+		}

+		if bc.Name == name {

+			matchingBuildConfigs = append(matchingBuildConfigs, &bc)

+		}

+	}

+

+	for _, bc := range matchingBuildConfigs {

+		var ref string

+		if bc.Spec.Source.Git != nil {

+			ref = bc.Spec.Source.Git.Ref

+		}

+		if ref == "" {

+			ref = "master"

+		}

+		fmt.Fprintf(out, "%s %s\n", bc.Name, ref)

+	}

+

+	return nil

+}

+

+func getClient() (client.Interface, error) {

+	clientConfig, err := restclient.InClusterConfig()

+	if err != nil {

+		return nil, fmt.Errorf("failed to get client config: %v", err)

+	}

+	osClient, err := client.New(clientConfig)

+	if err != nil {

+		return nil, fmt.Errorf("error obtaining OpenShift client: %v", err)

+	}

+	return osClient, nil

+}

@@ -5,7 +5,6 @@ package gitserver

 import (

 	"fmt"

-	"log"

 	"net/http"

 	"net/url"

 	"os"

@@ -16,6 +15,7 @@ import (

 	"github.com/AaronO/go-git-http"

 	"github.com/AaronO/go-git-http/auth"

+	"github.com/golang/glog"

 	"github.com/prometheus/client_golang/prometheus"

 	kapi "k8s.io/kubernetes/pkg/api"

@@ -35,31 +35,45 @@ GIT_HOME

   directory containing Git repositories; defaults to current directory

 PUBLIC_URL

   the url of this server for constructing URLs that point to this repository

+INTERNAL_URL

+  the url of this server that can be used internally by build configs in the cluster

 GIT_PATH

   path to Git binary; defaults to location of 'git' in PATH

 HOOK_PATH

   path to a directory containing hooks for all repositories; if not set no global hooks will be used

 ALLOW_GIT_PUSH

-  if 'no', pushes will be not be accepted; defaults to true

+  if 'false', pushes will be not be accepted; defaults to true

 ALLOW_ANON_GIT_PULL

-  if 'yes', pulls may be made without authorization; defaults to false

+  if 'true', pulls may be made without authorization; defaults to false

 ALLOW_GIT_HOOKS

-  if 'no', hooks cannot be read or set; defaults to true

+  if 'false', hooks cannot be read or set; defaults to true

 ALLOW_LAZY_CREATE

-  if 'no', repositories will not automatically be initialized on push; defaults to true

+  if 'false', repositories will not automatically be initialized on push; defaults to true

 REQUIRE_GIT_AUTH

   a user/password combination required to access the repo of the form "<user>:<password>"; defaults to none

 REQUIRE_SERVER_AUTH

-	a URL to an OpenShift server for verifying authorization credentials provided by a user. Requires

-	AUTOLINK_NAMESPACE to be set (the namespace that authorization will be checked in). Users must have

-	'get' on 'pods' to pull (be a viewer) and 'create' on 'pods' to push (be an editor)

+  a URL to an OpenShift server for verifying authorization credentials provided by a user. Requires

+  AUTOLINK_NAMESPACE to be set (the namespace that authorization will be checked in). Users must have

+  'get' on 'pods' to pull (be a viewer) and 'create' on 'pods' to push (be an editor)

 GIT_FORCE_CLEAN

-  if 'yes', any initial repository directories will be deleted prior to start; defaults to no

+  if 'true', any initial repository directories will be deleted prior to start; defaults to 'false'

   WARNING: this is destructive and you will lose any data you have already pushed

 GIT_INITIAL_CLONE_*=<url>[;<name>]

   each environment variable in this pattern will be cloned when the process starts; failures will be logged

   <name> must be [A-Z0-9_\-\.], the cloned directory name will be lowercased. If the name is invalid the

   process will halt. If the repository already exists on disk, it will be updated from the remote.

+AUTOLINK_KUBECONFIG

+  The location to read auth configuration from for autolinking.

+  If '-', use the service account token to link. The account

+  represented by this config must have the edit role on the

+  namespace.

+AUTOLINK_NAMESPACE

+  The namespace to autolink

+AUTOLINK_HOOK

+  The path to a script in the image to use as the default

+  post-receive hook - only set during link, so has no effect

+  on cloned repositories. See the "hooks" directory in the

+  image for examples.

 `

 )

@@ -82,9 +96,10 @@ func init() {

 // Config represents the configuration to use for running the server

 type Config struct {

-	Home      string

-	GitBinary string

-	URL       *url.URL

+	Home        string

+	GitBinary   string

+	URL         *url.URL

+	InternalURL *url.URL

 	AllowHooks      bool

 	AllowPush       bool

@@ -152,6 +167,14 @@ func NewEnviromentConfig() (*Config, error) {

 		config.URL = valid

 	}

+	if internalURL := os.Getenv("INTERNAL_URL"); len(internalURL) > 0 {

+		valid, err := url.Parse(internalURL)

+		if err != nil {

+			return nil, fmt.Errorf("INTERNAL_URL must be a valid URL: %v", err)

+		}

+		config.InternalURL = valid

+	}

+

 	gitpath := os.Getenv("GIT_PATH")

 	if len(gitpath) == 0 {

 		path, err := exec.LookPath("git")

@@ -162,9 +185,9 @@ func NewEnviromentConfig() (*Config, error) {

 	}

 	config.GitBinary = gitpath

-	config.AllowPush = os.Getenv("ALLOW_GIT_PUSH") != "no"

-	config.AllowHooks = os.Getenv("ALLOW_GIT_HOOKS") != "no"

-	config.AllowLazyCreate = os.Getenv("ALLOW_LAZY_CREATE") != "no"

+	config.AllowPush = os.Getenv("ALLOW_GIT_PUSH") != "false"

+	config.AllowHooks = os.Getenv("ALLOW_GIT_HOOKS") != "false"

+	config.AllowLazyCreate = os.Getenv("ALLOW_LAZY_CREATE") != "false"

 	if hookpath := os.Getenv("HOOK_PATH"); len(hookpath) != 0 {

 		path, err := filepath.Abs(hookpath)

@@ -177,7 +200,7 @@ func NewEnviromentConfig() (*Config, error) {

 		config.HookDirectory = path