Merge branch 'cloudbuild-plugin' of github.com:ebarriosjr/backstage into cloudbuild-plugin

plugins/api-docs/README.md

@@ -14,8 +14,9 @@ The plugin provides a standalone list of APIs, as well as an integration into th
 
 Right now, the following API formats are supported:
 
-- [OpenAPI](https://swagger.io/specification/) 2 & 3,
-- [AsyncAPI](https://www.asyncapi.com/docs/specifications/latest/),
+- [OpenAPI](https://swagger.io/specification/) 2 & 3
+- [AsyncAPI](https://www.asyncapi.com/docs/specifications/latest/)
+- [GraphQL](https://graphql.org/learn/schema/)
 
 Other formats are displayed as plain text, but this can easily be extented.
 

plugins/api-docs/package.json

@@ -29,6 +29,8 @@
     "@material-ui/core": "^4.11.0",
     "@material-ui/icons": "^4.9.1",
     "@material-ui/lab": "4.0.0-alpha.45",
+    "graphiql": "^1.0.0-alpha.10",
+    "graphql": "^15.3.0",
     "react": "^16.13.1",
     "react-dom": "^16.13.1",
     "react-router": "6.0.0-beta.0",

plugins/api-docs/src/catalog/EntityPageApi/EntityPageApi.tsx

@@ -16,15 +16,19 @@
 
 import { ComponentEntity, Entity } from '@backstage/catalog-model';
 import { Progress } from '@backstage/core';
-import React, { FC } from 'react';
 import { Grid } from '@material-ui/core';
+import React from 'react';
 import {
   ApiDefinitionCard,
   useComponentApiEntities,
   useComponentApiNames,
 } from '../../components';
 
-export const EntityPageApi: FC<{ entity: Entity }> = ({ entity }) => {
+type Props = {
+  entity: Entity;
+};
+
+export const EntityPageApi = ({ entity }: Props) => {
   const apiNames = useComponentApiNames(entity as ComponentEntity);
 
   const { apiEntities, loading } = useComponentApiEntities({

plugins/api-docs/src/components/ApiDefinitionCard/ApiDefinitionCard.tsx

@@ -15,14 +15,16 @@
  */
 
 import { ApiEntity } from '@backstage/catalog-model';
-import { TabbedCard, CardTab } from '@backstage/core';
-import React from 'react';
-import { PlainApiDefinitionWidget } from '../PlainApiDefinitionWidget';
+import { CardTab, useApi, TabbedCard } from '@backstage/core';
 import { Alert } from '@material-ui/lab';
+import React from 'react';
+import { apiDocsConfigRef } from '../../config';
+import { PlainApiDefinitionWidget } from '../PlainApiDefinitionWidget';
 import { OpenApiDefinitionWidget } from '../OpenApiDefinitionWidget';
 import { AsyncApiDefinitionWidget } from '../AsyncApiDefinitionWidget';
+import { GraphQlDefinitionWidget } from '../GraphQlDefinitionWidget';
 
-type ApiDefinitionWidget = {
+export type ApiDefinitionWidget = {
   type: string;
   title: string;
   component: (definition: string) => React.ReactElement;
@@ -47,39 +49,38 @@ export function defaultDefinitionWidgets(): ApiDefinitionWidget[] {
         <AsyncApiDefinitionWidget definition={definition} />
       ),
     },
+    {
+      type: 'graphql',
+      title: 'GraphQL',
+      rawLanguage: 'graphql',
+      component: definition => (
+        <GraphQlDefinitionWidget definition={definition} />
+      ),
+    },
   ];
 }
 
 type Props = {
   apiEntity?: ApiEntity;
-  definitionWidgets?: ApiDefinitionWidget[];
 };
 
-const defaultProps = {
-  definitionWidgets: defaultDefinitionWidgets(),
-};
-
-export const ApiDefinitionCard = (props: Props) => {
-  const { apiEntity, definitionWidgets } = {
-    ...defaultProps,
-    ...props,
-  };
+export const ApiDefinitionCard = ({ apiEntity }: Props) => {
+  const config = useApi(apiDocsConfigRef);
+  const { getApiDefinitionWidget } = config;
 
   if (!apiEntity) {
     return <Alert severity="error">Could not fetch the API</Alert>;
   }
 
-  const definitionWidget = definitionWidgets.find(
-    d => d.type === apiEntity.spec.type,
-  );
+  const definitionWidget = getApiDefinitionWidget(apiEntity);
 
   if (definitionWidget) {
     return (
       <TabbedCard title={apiEntity.metadata.name}>
-        <CardTab label={definitionWidget.title}>
+        <CardTab label={definitionWidget.title} key="widget">
           {definitionWidget.component(apiEntity.spec.definition)}
         </CardTab>
-        <CardTab label="Raw">
+        <CardTab label="Raw" key="raw">
           <PlainApiDefinitionWidget
             definition={apiEntity.spec.definition}
             language={definitionWidget.rawLanguage || apiEntity.spec.type}
@@ -94,7 +95,7 @@ export const ApiDefinitionCard = (props: Props) => {
       title={apiEntity.metadata.name}
       children={[
         // Has to be an array, otherwise typescript doesn't like that this has only a single child
-        <CardTab label={apiEntity.spec.type}>
+        <CardTab label={apiEntity.spec.type} key="raw">
           <PlainApiDefinitionWidget
             definition={apiEntity.spec.definition}
             language={apiEntity.spec.type}

plugins/api-docs/src/components/ApiDefinitionCard/index.ts

@@ -14,4 +14,8 @@
  * limitations under the License.
  */
 
-export { ApiDefinitionCard } from './ApiDefinitionCard';
+export type { ApiDefinitionWidget } from './ApiDefinitionCard';
+export {
+  ApiDefinitionCard,
+  defaultDefinitionWidgets,
+} from './ApiDefinitionCard';

plugins/api-docs/src/components/ApiEntityPage/ApiEntityPage.tsx

@@ -34,6 +34,7 @@ import { useAsync } from 'react-use';
 import { ApiDefinitionCard } from '../ApiDefinitionCard';
 
 const REDIRECT_DELAY = 1000;
+
 function headerProps(
   kind: string,
   namespace: string | undefined,

plugins/api-docs/src/components/ApiExplorerPage/ApiExplorerLayout.tsx

@@ -21,17 +21,15 @@ type Props = {
   children?: React.ReactNode;
 };
 
-const ApiCatalogLayout = ({ children }: Props) => {
+export const ApiExplorerLayout = ({ children }: Props) => {
   return (
     <Page theme={pageTheme.home}>
       <Header
         title="APIs"
-        subtitle="Backstage API Catalog"
-        pageTitleOverride="Home"
+        subtitle="Backstage API Explorer"
+        pageTitleOverride="APIs"
       />
       {children}
     </Page>
   );
 };
-
-export default ApiCatalogLayout;

plugins/api-docs/src/components/ApiExplorerPage/ApiExplorerPage.test.tsx

@@ -20,7 +20,8 @@ import { CatalogApi, catalogApiRef } from '@backstage/plugin-catalog';
 import { MockStorageApi, wrapInTestApp } from '@backstage/test-utils';
 import { render } from '@testing-library/react';
 import React from 'react';
-import { ApiCatalogPage } from './ApiCatalogPage';
+import { apiDocsConfigRef } from '../../config';
+import { ApiExplorerPage } from './ApiExplorerPage';
 
 describe('ApiCatalogPage', () => {
   const catalogApi: Partial<CatalogApi> = {
@@ -32,6 +33,7 @@ describe('ApiCatalogPage', () => {
           metadata: {
             name: 'Entity1',
           },
+          spec: { type: 'openapi' },
         },
         {
           apiVersion: 'backstage.io/v1alpha1',
@@ -39,12 +41,17 @@ describe('ApiCatalogPage', () => {
           metadata: {
             name: 'Entity2',
           },
+          spec: { type: 'openapi' },
         },
       ] as Entity[]),
     getLocationByEntity: () =>
       Promise.resolve({ id: 'id', type: 'github', target: 'url' }),
   };
 
+  const apiDocsConfig = {
+    getApiDefinitionWidget: () => undefined,
+  };
+
   const renderWrapped = (children: React.ReactNode) =>
     render(
       wrapInTestApp(
@@ -52,6 +59,7 @@ describe('ApiCatalogPage', () => {
           apis={ApiRegistry.from([
             [catalogApiRef, catalogApi],
             [storageApiRef, MockStorageApi.create()],
+            [apiDocsConfigRef, apiDocsConfig],
           ])}
         >
           {children}
@@ -63,7 +71,7 @@ describe('ApiCatalogPage', () => {
   // related to some theme issues in mui-table
   // https://github.com/mbrn/material-table/issues/1293
   it('should render', async () => {
-    const { findByText } = renderWrapped(<ApiCatalogPage />);
+    const { findByText } = renderWrapped(<ApiExplorerPage />);
     expect(await findByText(/APIs \(2\)/)).toBeInTheDocument();
   });
 });

plugins/api-docs/src/components/ApiExplorerPage/ApiExplorerPage.tsx

@@ -14,31 +14,42 @@
  * limitations under the License.
  */
 
-import { Content, useApi } from '@backstage/core';
+import { Content, ContentHeader, SupportButton, useApi } from '@backstage/core';
 import { catalogApiRef } from '@backstage/plugin-catalog';
+import { Button } from '@material-ui/core';
 import React from 'react';
+import { Link as RouterLink } from 'react-router-dom';
 import { useAsync } from 'react-use';
-import { ApiCatalogTable } from '../ApiCatalogTable';
-import ApiCatalogLayout from './ApiCatalogLayout';
+import { ApiExplorerTable } from '../ApiExplorerTable';
+import { ApiExplorerLayout } from './ApiExplorerLayout';
 
-const CatalogPageContents = () => {
+export const ApiExplorerPage = () => {
   const catalogApi = useApi(catalogApiRef);
   const { loading, error, value: matchingEntities } = useAsync(() => {
     return catalogApi.getEntities({ kind: 'API' });
   }, [catalogApi]);
 
   return (
-    <ApiCatalogLayout>
+    <ApiExplorerLayout>
       <Content>
-        <ApiCatalogTable
+        <ContentHeader title="">
+          <Button
+            variant="contained"
+            color="primary"
+            component={RouterLink}
+            to="/register-component"
+          >
+            Register Existing API
+          </Button>
+          <SupportButton>All your APIs</SupportButton>
+        </ContentHeader>
+        <ApiExplorerTable
           titlePreamble="APIs"
           entities={matchingEntities!}
           loading={loading}
           error={error}
         />
       </Content>
-    </ApiCatalogLayout>
+    </ApiExplorerLayout>
   );
 };
-
-export const ApiCatalogPage = () => <CatalogPageContents />;

plugins/api-docs/src/components/ApiExplorerPage/index.ts

@@ -14,4 +14,4 @@
  * limitations under the License.
  */
 
-export { ApiCatalogTable } from './ApiCatalogTable';
+export { ApiExplorerPage } from './ApiExplorerPage';

plugins/api-docs/src/components/ApiExplorerTable/ApiExplorerTable.test.tsx

@@ -15,39 +15,50 @@
  */
 
 import { Entity } from '@backstage/catalog-model';
+import { ApiProvider, ApiRegistry } from '@backstage/core';
 import { wrapInTestApp } from '@backstage/test-utils';
 import { render } from '@testing-library/react';
 import * as React from 'react';
-import { ApiCatalogTable } from './ApiCatalogTable';
+import { apiDocsConfigRef } from '../../config';
+import { ApiExplorerTable } from './ApiExplorerTable';
 
 const entites: Entity[] = [
   {
     apiVersion: 'backstage.io/v1alpha1',
     kind: 'API',
     metadata: { name: 'api1' },
+    spec: { type: 'openapi' },
   },
   {
     apiVersion: 'backstage.io/v1alpha1',
     kind: 'API',
     metadata: { name: 'api2' },
+    spec: { type: 'openapi' },
   },
   {
     apiVersion: 'backstage.io/v1alpha1',
     kind: 'API',
     metadata: { name: 'api3' },
+    spec: { type: 'grpc' },
   },
 ];
 
+const apiRegistry = ApiRegistry.with(apiDocsConfigRef, {
+  getApiDefinitionWidget: () => undefined,
+});
+
 describe('ApiCatalogTable component', () => {
   it('should render error message when error is passed in props', async () => {
     const rendered = render(
       wrapInTestApp(
-        <ApiCatalogTable
-          titlePreamble="APIs"
-          entities={[]}
-          loading={false}
-          error={{ code: 'error' }}
-        />,
+        <ApiProvider apis={apiRegistry}>
+          <ApiExplorerTable
+            titlePreamble="APIs"
+            entities={[]}
+            loading={false}
+            error={{ code: 'error' }}
+          />
+        </ApiProvider>,
       ),
     );
     const errorMessage = await rendered.findByText(
@@ -59,11 +70,13 @@ describe('ApiCatalogTable component', () => {
   it('should display entity names when loading has finished and no error occurred', async () => {
     const rendered = render(
       wrapInTestApp(
-        <ApiCatalogTable
-          titlePreamble="APIs"
-          entities={entites}
-          loading={false}
-        />,
+        <ApiProvider apis={apiRegistry}>
+          <ApiExplorerTable
+            titlePreamble="APIs"
+            entities={entites}
+            loading={false}
+          />
+        </ApiProvider>,
       ),
     );
     expect(rendered.getByText(/APIs \(3\)/)).toBeInTheDocument();

plugins/api-docs/src/components/ApiExplorerTable/ApiExplorerTable.tsx

@@ -14,14 +14,23 @@
  * limitations under the License.
  */
 
-import { Entity } from '@backstage/catalog-model';
-import { Table, TableColumn } from '@backstage/core';
-import { Link } from '@material-ui/core';
+import { ApiEntityV1alpha1, Entity } from '@backstage/catalog-model';
+import { Table, TableColumn, useApi } from '@backstage/core';
+import { Chip, Link } from '@material-ui/core';
 import { Alert } from '@material-ui/lab';
 import React from 'react';
 import { generatePath, Link as RouterLink } from 'react-router-dom';
+import { apiDocsConfigRef } from '../../config';
 import { entityRoute } from '../../routes';
 
+const ApiTypeTitle = ({ apiEntity }: { apiEntity: ApiEntityV1alpha1 }) => {
+  const config = useApi(apiDocsConfigRef);
+  const definition = config.getApiDefinitionWidget(apiEntity);
+  const type = definition ? definition.title : apiEntity.spec.type;
+
+  return <span>{type}</span>;
+};
+
 const columns: TableColumn<Entity>[] = [
   {
     title: 'Name',
@@ -45,25 +54,55 @@ const columns: TableColumn<Entity>[] = [
       </Link>
     ),
   },
+  {
+    title: 'Owner',
+    field: 'spec.owner',
+  },
+  {
+    title: 'Lifecycle',
+    field: 'spec.lifecycle',
+  },
+  {
+    title: 'Type',
+    field: 'spec.type',
+    render: (entity: Entity) => (
+      <ApiTypeTitle apiEntity={entity as ApiEntityV1alpha1} />
+    ),
+  },
   {
     title: 'Description',
     field: 'metadata.description',
   },
+  {
+    title: 'Tags',
+    field: 'metadata.tags',
+    cellStyle: {
+      padding: '0px 16px 0px 20px',
+    },
+    render: (entity: Entity) => (
+      <>
+        {entity.metadata.tags &&
+          entity.metadata.tags.map(t => (
+            <Chip key={t} label={t} style={{ marginBottom: '0px' }} />
+          ))}
+      </>
+    ),
+  },
 ];
 
-type CatalogTableProps = {
+type ExplorerTableProps = {
   entities: Entity[];
   titlePreamble: string;
   loading: boolean;
   error?: any;
 };
 
-export const ApiCatalogTable = ({
+export const ApiExplorerTable = ({
   entities,
   loading,
   error,
   titlePreamble,
-}: CatalogTableProps) => {
+}: ExplorerTableProps) => {
   if (error) {
     return (
       <div>

plugins/api-docs/src/components/ApiExplorerTable/index.ts

@@ -14,4 +14,4 @@
  * limitations under the License.
  */
 
-export { ApiCatalogPage } from './ApiCatalogPage';
+export { ApiExplorerTable } from './ApiExplorerTable';

plugins/api-docs/src/components/GraphQlDefinitionWidget/GraphQlDefinitionWidget.tsx

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2020 Spotify AB
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import React, { Suspense } from 'react';
+import { buildSchema } from 'graphql';
+import { makeStyles } from '@material-ui/core/styles';
+import { Progress } from '@backstage/core';
+import { BackstageTheme } from '@backstage/theme';
+
+const GraphiQL = React.lazy(() => import('graphiql'));
+
+const useStyles = makeStyles<BackstageTheme>(() => ({
+  root: {
+    height: '100%',
+    display: 'flex',
+    flexFlow: 'column nowrap',
+  },
+  graphiQlWrapper: {
+    flex: 1,
+    '@global': {
+      '.graphiql-container': {
+        boxSizing: 'initial',
+        height: '100%',
+        minHeight: '600px',
+        flex: '1 1 auto',
+      },
+    },
+  },
+}));
+
+type Props = {
+  definition: any;
+};
+
+export const GraphQlDefinitionWidget = ({ definition }: Props) => {
+  const classes = useStyles();
+  const schema = buildSchema(definition);
+
+  return (
+    <Suspense fallback={<Progress />}>
+      <div className={classes.root}>
+        <div className={classes.graphiQlWrapper}>
+          <GraphiQL
+            fetcher={() => Promise.resolve(null) as any}
+            schema={schema}
+            docExplorerOpen
+            defaultSecondaryEditorOpen={false}
+          />
+        </div>
+      </div>
+    </Suspense>
+  );
+};

plugins/api-docs/src/components/GraphQlDefinitionWidget/index.ts

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2020 Spotify AB
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export { GraphQlDefinitionWidget } from './GraphQlDefinitionWidget';

plugins/api-docs/src/components/index.ts

@@ -14,7 +14,11 @@
  * limitations under the License.
  */
 
-export { ApiDefinitionCard } from './ApiDefinitionCard';
+export type { ApiDefinitionWidget } from './ApiDefinitionCard';
+export {
+  ApiDefinitionCard,
+  defaultDefinitionWidgets,
+} from './ApiDefinitionCard';
 export { AsyncApiDefinitionWidget } from './AsyncApiDefinitionWidget';
 export { OpenApiDefinitionWidget } from './OpenApiDefinitionWidget';
 export { PlainApiDefinitionWidget } from './PlainApiDefinitionWidget';

plugins/api-docs/src/config.ts

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2020 Spotify AB
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ApiEntity } from '@backstage/catalog-model';
+import { createApiRef } from '@backstage/core';
+import { ApiDefinitionWidget } from './components';
+
+export const apiDocsConfigRef = createApiRef<ApiDocsConfig>({
+  id: 'plugin.api-docs.config',
+  description: 'Used to configure api-docs widgets',
+});
+
+export interface ApiDocsConfig {
+  getApiDefinitionWidget: (
+    apiEntity: ApiEntity,
+  ) => ApiDefinitionWidget | undefined;
+}

plugins/api-docs/src/plugin.ts

@@ -14,15 +14,32 @@
  * limitations under the License.
  */
 
-import { createPlugin } from '@backstage/core';
-import { ApiCatalogPage } from './components/ApiCatalogPage/ApiCatalogPage';
+import { ApiEntity } from '@backstage/catalog-model';
+import { createApiFactory, createPlugin } from '@backstage/core';
+import { ApiExplorerPage } from './components/ApiExplorerPage/ApiExplorerPage';
+import { defaultDefinitionWidgets } from './components/ApiDefinitionCard';
 import { ApiEntityPage } from './components/ApiEntityPage/ApiEntityPage';
 import { entityRoute, rootRoute } from './routes';
+import { apiDocsConfigRef } from './config';
 
 export const plugin = createPlugin({
   id: 'api-docs',
+  apis: [
+    createApiFactory({
+      api: apiDocsConfigRef,
+      deps: {},
+      factory: () => {
+        const definitionWidgets = defaultDefinitionWidgets();
+        return {
+          getApiDefinitionWidget: (apiEntity: ApiEntity) => {
+            return definitionWidgets.find(d => d.type === apiEntity.spec.type);
+          },
+        };
+      },
+    }),
+  ],
   register({ router }) {
-    router.addRoute(rootRoute, ApiCatalogPage);
+    router.addRoute(rootRoute, ApiExplorerPage);
     router.addRoute(entityRoute, ApiEntityPage);
   },
 });

plugins/api-docs/src/routes.ts

@@ -23,11 +23,13 @@ export const rootRoute = createRouteRef({
   path: '/api-docs',
   title: 'APIs',
 });
+
 export const entityRoute = createRouteRef({
   icon: NoIcon,
   path: '/api-docs/:optionalNamespaceAndName/',
   title: 'API',
 });
+
 export const catalogRoute = createRouteRef({
   icon: NoIcon,
   path: '',

plugins/catalog-backend/src/ingestion/LocationReaders.ts

@@ -78,7 +78,7 @@ export class LocationReaders implements LocationReader {
       StaticLocationProcessor.fromConfig(config),
       new FileReaderProcessor(),
       new GithubReaderProcessor(config),
-      new GithubApiReaderProcessor(config),
+      GithubApiReaderProcessor.fromConfig(config),
       new GitlabApiReaderProcessor(config),
       new GitlabReaderProcessor(),
       new BitbucketApiReaderProcessor(config),

plugins/catalog-backend/src/ingestion/processors/GithubApiReaderProcessor.test.ts

@@ -14,116 +14,149 @@
  * limitations under the License.
  */
 
-import { GithubApiReaderProcessor } from './GithubApiReaderProcessor';
+import { LocationSpec } from '@backstage/catalog-model';
 import { ConfigReader } from '@backstage/config';
+import {
+  getRawUrl,
+  getRequestOptions,
+  GithubApiReaderProcessor,
+  ProviderConfig,
+  readConfig,
+} from './GithubApiReaderProcessor';
 
 describe('GithubApiReaderProcessor', () => {
-  const createConfig = (token: string | undefined) =>
-    ConfigReader.fromConfigs([
-      {
-        context: '',
-        data: {
-          catalog: {
-            processors: {
-              githubApi: {
-                privateToken: token,
-              },
-            },
-          },
-        },
-      },
-    ]);
+  describe('getRequestOptions', () => {
+    it('sets the correct API version', () => {
+      const config: ProviderConfig = { target: '', apiBaseUrl: '' };
+      expect((getRequestOptions(config).headers as any).Accept).toEqual(
+        'application/vnd.github.v3.raw',
+      );
+    });
 
-  it('should build raw api', () => {
-    const processor = new GithubApiReaderProcessor(createConfig(undefined));
-
-    const tests = [
-      {
-        target: 'https://github.com/a/b/blob/master/path/to/c.yaml',
-        url: new URL(
-          'https://api.github.com/repos/a/b/contents/path/to/c.yaml?ref=master',
-        ),
-        err: undefined,
-      },
-      {
-        target: 'https://api.com/a/b/blob/master/path/to/c.yaml',
-        url: null,
-        err:
-          'Incorrect url: https://api.com/a/b/blob/master/path/to/c.yaml, Error: Wrong GitHub URL or Invalid file path',
-      },
-      {
-        target: 'com/a/b/blob/master/path/to/c.yaml',
-        url: null,
-        err:
-          'Incorrect url: com/a/b/blob/master/path/to/c.yaml, TypeError: Invalid URL: com/a/b/blob/master/path/to/c.yaml',
-      },
-      {
-        target:
-          'https://github.com/spotify/backstage/blob/master/packages/catalog-model/examples/playback-order-component.yaml',
-        url: new URL(
-          'https://api.github.com/repos/spotify/backstage/contents/packages/catalog-model/examples/playback-order-component.yaml?ref=master',
-        ),
-        err: undefined,
-      },
-    ];
-
-    for (const test of tests) {
-      if (test.err) {
-        expect(() => processor.buildRawUrl(test.target)).toThrowError(test.err);
-      } else if (test.url) {
-        expect(processor.buildRawUrl(test.target).toString()).toEqual(
-          test.url.toString(),
-        );
-      } else {
-        throw new Error(
-          'This should not have happened. Either err or url should have matched.',
-        );
-      }
-    }
+    it('inserts a token when needed', () => {
+      const withToken: ProviderConfig = {
+        target: '',
+        apiBaseUrl: '',
+        token: 'A',
+      };
+      const withoutToken: ProviderConfig = {
+        target: '',
+        apiBaseUrl: '',
+      };
+      expect(
+        (getRequestOptions(withToken).headers as any).Authorization,
+      ).toEqual('token A');
+      expect(
+        (getRequestOptions(withoutToken).headers as any).Authorization,
+      ).toBeUndefined();
+    });
   });
 
-  it('should return request options', () => {
-    const tests = [
-      {
-        token: '0123456789',
-        expect: {
-          headers: {
-            Accept: 'application/vnd.github.v3.raw',
-            Authorization: 'token 0123456789',
-          },
-        },
-      },
-      {
-        token: '',
-        err:
-          "Invalid type in config for key 'catalog.processors.githubApi.privateToken' in '', got empty-string, wanted string",
-        expect: {
-          headers: {
-            Accept: 'application/vnd.github.v3.raw',
-          },
-        },
-      },
-      {
-        token: undefined,
-        expect: {
-          headers: {
-            Accept: 'application/vnd.github.v3.raw',
-          },
-        },
-      },
-    ];
+  describe('getRawUrl', () => {
+    it('rejects targets that do not look like URLs', () => {
+      const config: ProviderConfig = { target: '', apiBaseUrl: '' };
+      expect(() => getRawUrl('a/b', config)).toThrow(/Incorrect URL: a\/b/);
+    });
 
-    for (const test of tests) {
-      if (test.err) {
-        expect(
-          () => new GithubApiReaderProcessor(createConfig(test.token)),
-        ).toThrowError(test.err);
-      } else {
-        const processor = new GithubApiReaderProcessor(
-          createConfig(test.token),
-        );
-        expect(processor.getRequestOptions()).toEqual(test.expect);
-      }
+    it('passes through the happy path', () => {
+      const config: ProviderConfig = {
+        target: 'https://github.com',
+        apiBaseUrl: 'https://api.github.com',
+      };
+      expect(
+        getRawUrl(
+          'https://github.com/a/b/blob/branchname/path/to/c.yaml',
+          config,
+        ),
+      ).toEqual(
+        new URL(
+          'https://api.github.com/repos/a/b/contents/path/to/c.yaml?ref=branchname',
+        ),
+      );
+    });
+  });
+
+  describe('readConfig', () => {
+    function config(
+      providers: { target: string; apiBaseUrl?: string; token?: string }[],
+    ) {
+      return ConfigReader.fromConfigs([
+        {
+          context: '',
+          data: {
+            catalog: { processors: { githubApi: { providers } } },
+          },
+        },
+      ]);
     }
+
+    it('adds a default GitHub entry when missing', () => {
+      const output = readConfig(config([]));
+      expect(output).toEqual([
+        { target: 'https://github.com', apiBaseUrl: 'https://api.github.com' },
+      ]);
+    });
+
+    it('injects the correct GitHub API base URL when missing', () => {
+      const output = readConfig(config([{ target: 'https://github.com' }]));
+      expect(output).toEqual([
+        { target: 'https://github.com', apiBaseUrl: 'https://api.github.com' },
+      ]);
+    });
+
+    it('rejects custom targets with no API base URL', () => {
+      expect(() =>
+        readConfig(config([{ target: 'https://ghe.company.com' }])),
+      ).toThrow(
+        'Provider at https://ghe.company.com must configure an explicit apiBaseUrl',
+      );
+    });
+
+    it('rejects funky configs', () => {
+      expect(() => readConfig(config([{ target: 7 } as any]))).toThrow(
+        /target/,
+      );
+      expect(() => readConfig(config([{ noTarget: '7' } as any]))).toThrow(
+        /target/,
+      );
+      expect(() =>
+        readConfig(
+          config([{ target: 'https://github.com', apiBaseUrl: 7 } as any]),
+        ),
+      ).toThrow(/apiBaseUrl/);
+      expect(() =>
+        readConfig(config([{ target: 'https://github.com', token: 7 } as any])),
+      ).toThrow(/token/);
+    });
+  });
+
+  describe('implementation', () => {
+    it('rejects unknown types', async () => {
+      const processor = new GithubApiReaderProcessor([
+        { target: 'https://github.com', apiBaseUrl: 'https://api.github.com' },
+      ]);
+      const location: LocationSpec = {
+        type: 'not-github/api',
+        target: 'https://github.com',
+      };
+      await expect(
+        processor.readLocation(location, false, () => {}),
+      ).resolves.toBeFalsy();
+    });
+
+    it('rejects unknown targets', async () => {
+      const processor = new GithubApiReaderProcessor([
+        { target: 'https://github.com', apiBaseUrl: 'https://api.github.com' },
+      ]);
+      const location: LocationSpec = {
+        type: 'github/api',
+        target: 'https://not.github.com/apa',
+      };
+      await expect(
+        processor.readLocation(location, false, () => {}),
+      ).rejects.toThrow(
+        /There is no GitHub provider that matches https:\/\/not.github.com\/apa/,
+      );
+    });
   });
 });

plugins/catalog-backend/src/ingestion/processors/GithubApiReaderProcessor.ts

@@ -15,34 +15,135 @@
  */
 
 import { LocationSpec } from '@backstage/catalog-model';
-import fetch, { RequestInit, HeadersInit } from 'node-fetch';
+import { Config } from '@backstage/config';
+import fetch, { HeadersInit, RequestInit } from 'node-fetch';
 import * as result from './results';
 import { LocationProcessor, LocationProcessorEmit } from './types';
-import { Config } from '@backstage/config';
 
-export class GithubApiReaderProcessor implements LocationProcessor {
-  private privateToken: string;
+/**
+ * The configuration parameters for a single GitHub API provider.
+ */
+export type ProviderConfig = {
+  /**
+   * The prefix of the target that this matches on, e.g. "https://github.com",
+   * with no trailing slash.
+   */
+  target: string;
 
-  constructor(config: Config) {
-    this.privateToken =
-      config.getOptionalString('catalog.processors.githubApi.privateToken') ??
-      '';
+  /**
+   * The base URL of the API of this provider, e.g. "https://api.github.com",
+   * with no trailing slash.
+   */
+  apiBaseUrl: string;
+
+  /**
+   * The authorization token to use for requests to this provider.
+   *
+   * If no token is specified, anonymous API access is used.
+   */
+  token?: string;
+};
+
+export function getRequestOptions(provider: ProviderConfig): RequestInit {
+  const headers: HeadersInit = {
+    Accept: 'application/vnd.github.v3.raw',
+  };
+
+  if (provider.token) {
+    headers.Authorization = `token ${provider.token}`;
   }
 
-  getRequestOptions(): RequestInit {
-    const headers: HeadersInit = {
-      Accept: 'application/vnd.github.v3.raw',
-    };
+  return {
+    headers,
+  };
+}
 
-    if (this.privateToken !== '') {
-      headers.Authorization = `token ${this.privateToken}`;
+// Converts for example
+// from: https://github.com/a/b/blob/branchname/path/to/c.yaml
+// to:   https://api.github.com/repos/a/b/contents/path/to/c.yaml?ref=branchname
+export function getRawUrl(target: string, provider: ProviderConfig): URL {
+  try {
+    const oldPath = new URL(target).pathname.split('/');
+    const [, userOrOrg, repoName, blobOrRaw, ref, ...restOfPath] = oldPath;
+
+    if (
+      !userOrOrg ||
+      !repoName ||
+      (blobOrRaw !== 'blob' && blobOrRaw !== 'raw') ||
+      !restOfPath.join('/').match(/\.ya?ml$/)
+    ) {
+      throw new Error('Wrong URL or Invalid file path');
     }
 
-    const requestOptions: RequestInit = {
-      headers,
-    };
+    // Transform to API path
+    const newPath = [
+      'repos',
+      userOrOrg,
+      repoName,
+      'contents',
+      ...restOfPath,
+    ].join('/');
+    return new URL(`${provider.apiBaseUrl}/${newPath}?ref=${ref}`);
+  } catch (e) {
+    throw new Error(`Incorrect URL: ${target}, ${e}`);
+  }
+}
 
-    return requestOptions;
+export function readConfig(configRoot: Config): ProviderConfig[] {
+  const providers: ProviderConfig[] = [];
+
+  // In a previous version of the configuration, we only supported github,
+  // and the "privateToken" key held the token to use for it. The new
+  // configuration method is to use the "providers" key instead.
+  const config = configRoot.getOptionalConfig('catalog.processors.githubApi');
+  const providerConfigs = config?.getOptionalConfigArray('providers') ?? [];
+  const legacyToken = config?.getOptionalString('privateToken');
+
+  // First read all the explicit providers
+  for (const providerConfig of providerConfigs) {
+    const target = providerConfig.getString('target').replace(/\/+$/, '');
+    let apiBaseUrl = providerConfig.getOptionalString('apiBaseUrl');
+    const token = providerConfig.getOptionalString('token');
+
+    if (apiBaseUrl) {
+      apiBaseUrl = apiBaseUrl.replace(/\/+$/, '');
+    } else if (target === 'https://github.com') {
+      apiBaseUrl = 'https://api.github.com';
+    } else {
+      throw new Error(
+        `Provider at ${target} must configure an explicit apiBaseUrl`,
+      );
+    }
+
+    providers.push({ target, apiBaseUrl, token });
+  }
+
+  // If no explicit github.com provider was added, put one in the list as
+  // a convenience
+  if (!providers.some(p => p.target === 'https://github.com')) {
+    providers.push({
+      target: 'https://github.com',
+      apiBaseUrl: 'https://api.github.com',
+      token: legacyToken,
+    });
+  }
+
+  return providers;
+}
+
+/**
+ * A processor that adds the ability to read files from GitHub v3 APIs, such as
+ * the one exposed by GitHub itself.
+ */
+export class GithubApiReaderProcessor implements LocationProcessor {
+  private providers: ProviderConfig[];
+
+  static fromConfig(config: Config) {
+    return new GithubApiReaderProcessor(readConfig(config));
+  }
+
+  constructor(providers: ProviderConfig[]) {
+    this.providers = providers;
   }
 
   async readLocation(
@@ -54,10 +155,19 @@ export class GithubApiReaderProcessor implements LocationProcessor {
       return false;
     }
 
-    try {
-      const url = this.buildRawUrl(location.target);
+    const provider = this.providers.find(p =>
+      location.target.startsWith(`${p.target}/`),
+    );
+    if (!provider) {
+      throw new Error(
+        `There is no GitHub provider that matches ${location.target}. Please add a configuration entry for it under catalog.github.processors.githubApi.`,
+      );
+    }
 
-      const response = await fetch(url.toString(), this.getRequestOptions());
+    try {
+      const url = getRawUrl(location.target, provider);
+      const options = getRequestOptions(provider);
+      const response = await fetch(url.toString(), options);
 
       if (response.ok) {
         const data = await response.buffer();
@@ -79,50 +189,4 @@ export class GithubApiReaderProcessor implements LocationProcessor {
 
     return true;
   }
-
-  // Converts
-  // from: https://github.com/a/b/blob/master/path/to/c.yaml
-  // to:   https://api.github.com/repos/a/b/contents/path/to/c.yaml?ref=master
-  buildRawUrl(target: string): URL {
-    try {
-      const url = new URL(target);
-
-      const [
-        empty,
-        userOrOrg,
-        repoName,
-        blobKeyword,
-        ref,
-        ...restOfPath
-      ] = url.pathname.split('/');
-
-      if (
-        url.hostname !== 'github.com' ||
-        empty !== '' ||
-        userOrOrg === '' ||
-        repoName === '' ||
-        blobKeyword !== 'blob' ||
-        !restOfPath.join('/').match(/\.yaml$/)
-      ) {
-        throw new Error('Wrong GitHub URL or Invalid file path');
-      }
-
-      // transform to api
-      url.pathname = [
-        empty,
-        'repos',
-        userOrOrg,
-        repoName,
-        'contents',
-        ...restOfPath,
-      ].join('/');
-      url.hostname = 'api.github.com';
-      url.protocol = 'https';
-      url.search = `ref=${ref}`;
-
-      return url;
-    } catch (e) {
-      throw new Error(`Incorrect url: ${target}, ${e}`);
-    }
-  }
 }

plugins/jenkins/README.md

@@ -14,17 +14,7 @@ Website: [https://jenkins.io/](https://jenkins.io/)
 yarn add @backstage/plugin-jenkins
 ```
 
-2. Add plugin API to your Backstage instance:
-
-```js
-// packages/app/src/api.ts
-import { JenkinsApi, jenkinsApiRef } from '@backstage/plugin-jenkins';
-
-const builder = ApiRegistry.builder();
-builder.add(jenkinsApiRef, new JenkinsApi(`${backendUrl}/proxy/jenkins/api`));
-```
-
-2. Add plugin itself:
+2. Add plugin:
 
 ```js
 // packages/app/src/plugins.ts
@@ -63,7 +53,7 @@ metadata:
   name: 'your-component'
   description: 'a description'
   annotations:
-    backstage.io/jenkins-github-folder: 'folder-name/job-name'
+    jenkins.io/github-folder: 'folder-name/job-name'
 spec:
   type: service
   lifecycle: experimental

plugins/jenkins/package.json

@@ -23,6 +23,7 @@
   "dependencies": {
     "@backstage/catalog-model": "^0.1.1-alpha.21",
     "@backstage/core": "^0.1.1-alpha.21",
+    "@backstage/plugin-catalog": "^0.1.1-alpha.21",
     "@backstage/theme": "^0.1.1-alpha.21",
     "@material-ui/core": "^4.11.0",
     "@material-ui/icons": "^4.9.1",

plugins/jenkins/src/api/index.ts

@@ -15,7 +15,7 @@
  */
 
 import { createApiRef } from '@backstage/core';
-import { CITableBuildInfo } from '../pages/BuildsPage/lib/CITable';
+import { CITableBuildInfo } from '../components/BuildsPage/lib/CITable';
 
 const jenkins = require('jenkins');
 
@@ -65,6 +65,21 @@ export class JenkinsApi {
       })
       .pop();
 
+    const author = jobDetails.actions
+      .filter(
+        (action: any) =>
+          action._class ===
+          'jenkins.scm.api.metadata.ContributorMetadataAction',
+      )
+      .map((action: any) => {
+        return action.contributorDisplayName;
+      })
+      .pop();
+
+    if (author) {
+      scmInfo.author = author;
+    }
+
     return scmInfo;
   }
 
@@ -154,12 +169,15 @@ export class JenkinsApi {
     if (jobScmInfo) {
       source.url = jobScmInfo?.url;
       source.displayName = jobScmInfo?.displayName;
+      source.author = jobScmInfo?.author;
     }
 
     const path = new URL(jenkinsResult.url).pathname;
 
     return {
       id: path,
+      buildNumber: jenkinsResult.number,
+      buildUrl: jenkinsResult.url,
       buildName: jenkinsResult.fullDisplayName,
       status: jenkinsResult.building ? 'running' : jenkinsResult.result,
       onRestartClick: () => {

plugins/jenkins/src/components/BuildWithStepsPage/BuildWithStepsPage.tsx

@@ -0,0 +1,134 @@
+/*
+ * Copyright 2020 Spotify AB
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import React from 'react';
+import { useParams } from 'react-router-dom';
+import { Content, Link } from '@backstage/core';
+import {
+  Typography,
+  Breadcrumbs,
+  Paper,
+  TableContainer,
+  Table,
+  TableRow,
+  TableCell,
+  TableBody,
+  Link as MaterialLink,
+} from '@material-ui/core';
+import { makeStyles } from '@material-ui/core/styles';
+import { useBuildWithSteps } from '../useBuildWithSteps';
+import { useProjectSlugFromEntity } from '../useProjectSlugFromEntity';
+import { JenkinsRunStatus } from '../BuildsPage/lib/Status';
+import ExternalLinkIcon from '@material-ui/icons/Launch';
+
+const useStyles = makeStyles(theme => ({
+  root: {
+    maxWidth: 720,
+    margin: theme.spacing(2),
+  },
+  table: {
+    padding: theme.spacing(1),
+  },
+  externalLinkIcon: {
+    fontSize: 'inherit',
+    verticalAlign: 'bottom',
+  },
+}));
+
+const Page = () => (
+  <Content>
+    <BuildWithStepsView />
+  </Content>
+);
+
+const BuildWithStepsView = () => {
+  const { owner, repo } = useProjectSlugFromEntity();
+  const { branch, buildNumber } = useParams();
+  const classes = useStyles();
+  const buildPath = `${owner}/${repo}/${branch}/${buildNumber}`;
+  const [{ value }] = useBuildWithSteps(buildPath);
+
+  return (
+    <div className={classes.root}>
+      <Breadcrumbs aria-label="breadcrumb">
+        <Link to="../../..">Jobs</Link>
+        <Typography>Run</Typography>
+      </Breadcrumbs>
+      <TableContainer component={Paper} className={classes.table}>
+        <Table>
+          <TableBody>
+            <TableRow>
+              <TableCell>
+                <Typography noWrap>Branch</Typography>
+              </TableCell>
+              <TableCell>{value?.source?.branchName}</TableCell>
+            </TableRow>
+            <TableRow>
+              <TableCell>
+                <Typography noWrap>Message</Typography>
+              </TableCell>
+              <TableCell>{value?.source?.displayName}</TableCell>
+            </TableRow>
+            <TableRow>
+              <TableCell>
+                <Typography noWrap>Commit ID</Typography>
+              </TableCell>
+              <TableCell>{value?.source?.commit?.hash}</TableCell>
+            </TableRow>
+            <TableRow>
+              <TableCell>
+                <Typography noWrap>Status</Typography>
+              </TableCell>
+              <TableCell>
+                <JenkinsRunStatus status={value?.status} />
+              </TableCell>
+            </TableRow>
+            <TableRow>
+              <TableCell>
+                <Typography noWrap>Author</Typography>
+              </TableCell>
+              <TableCell>{value?.source?.author}</TableCell>
+            </TableRow>
+            <TableRow>
+              <TableCell>
+                <Typography noWrap>Jenkins</Typography>
+              </TableCell>
+              <TableCell>
+                <MaterialLink target="_blank" href={value?.buildUrl}>
+                  View on Jenkins{' '}
+                  <ExternalLinkIcon className={classes.externalLinkIcon} />
+                </MaterialLink>
+              </TableCell>
+            </TableRow>
+            <TableRow>
+              <TableCell>
+                <Typography noWrap>GitHub</Typography>
+              </TableCell>
+              <TableCell>
+                <MaterialLink target="_blank" href={value?.source.url}>
+                  View on GitHub{' '}
+                  <ExternalLinkIcon className={classes.externalLinkIcon} />
+                </MaterialLink>
+              </TableCell>
+            </TableRow>
+          </TableBody>
+        </Table>
+      </TableContainer>
+    </div>
+  );
+};
+
+export default Page;
+export { BuildWithStepsView as BuildWithSteps };

plugins/jenkins/src/components/BuildsPage/lib/CITable/CITable.tsx

@@ -14,21 +14,26 @@
  * limitations under the License.
  */
 import React, { FC } from 'react';
-import { Link, Typography, Box, IconButton } from '@material-ui/core';
+import { Box, IconButton, Link, Typography } from '@material-ui/core';
 import RetryIcon from '@material-ui/icons/Replay';
 import GitHubIcon from '@material-ui/icons/GitHub';
-import { Link as RouterLink } from 'react-router-dom';
+import { generatePath, Link as RouterLink } from 'react-router-dom';
 import { Table, TableColumn } from '@backstage/core';
 import { JenkinsRunStatus } from '../Status';
+import { useBuilds } from '../../../useBuilds';
+import { useProjectSlugFromEntity } from '../../../useProjectSlugFromEntity';
+import { buildRouteRef } from '../../../../plugin';
 
 export type CITableBuildInfo = {
   id: string;
   buildName: string;
-  buildUrl?: string;
+  buildNumber: number;
+  buildUrl: string;
   source: {
     branchName: string;
     url: string;
     displayName: string;
+    author?: string;
     commit: {
       hash: string;
     };
@@ -105,7 +110,13 @@ const generatedColumns: TableColumn[] = [
     field: 'buildName',
     highlight: true,
     render: (row: Partial<CITableBuildInfo>) => (
-      <Link component={RouterLink} to={`/jenkins/job?url=${row.id}`}>
+      <Link
+        component={RouterLink}
+        to={generatePath(buildRouteRef.path, {
+          branch: row.source?.branchName!,
+          buildNumber: row.buildNumber?.toString()!,
+        })}
+      >
         {row.buildName}
       </Link>
     ),
@@ -177,7 +188,8 @@ type Props = {
   pageSize: number;
   onChangePageSize: (pageSize: number) => void;
 };
-export const CITable: FC<Props> = ({
+
+export const CITableView: FC<Props> = ({
   projectName,
   loading,
   pageSize,
@@ -191,7 +203,7 @@ export const CITable: FC<Props> = ({
   return (
     <Table
       isLoading={loading}
-      options={{ paging: true, pageSize }}
+      options={{ paging: true, pageSize, padding: 'dense' }}
       totalCount={total}
       page={page}
       actions={[
@@ -202,7 +214,7 @@ export const CITable: FC<Props> = ({
           onClick: () => retry(),
         },
       ]}
-      data={builds}
+      data={builds ?? []}
       onChangePage={onChangePage}
       onChangeRowsPerPage={onChangePageSize}
       title={
@@ -216,3 +228,18 @@ export const CITable: FC<Props> = ({
     />
   );
 };
+
+export const CITable = () => {
+  const { owner, repo } = useProjectSlugFromEntity();
+
+  const [tableProps, { setPage, retry, setPageSize }] = useBuilds(owner, repo);
+
+  return (
+    <CITableView
+      {...tableProps}
+      retry={retry}
+      onChangePageSize={setPageSize}
+      onChangePage={setPage}
+    />
+  );
+};

plugins/jenkins/src/components/Cards/Cards.tsx

@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 import React from 'react';
-import { Entity } from '@backstage/catalog-model';
 import { Link, Theme, makeStyles, LinearProgress } from '@material-ui/core';
 import { InfoCard, StructuredMetadataTable } from '@backstage/core';
 import ExternalLinkIcon from '@material-ui/icons/Launch';
-import { useBuilds } from '../../state';
-import { JenkinsRunStatus } from '../../pages/BuildsPage/lib/Status';
+import { useBuilds } from '../useBuilds';
+import { JenkinsRunStatus } from '../BuildsPage/lib/Status';
+import { useProjectSlugFromEntity } from '../useProjectSlugFromEntity';
 
 const useStyles = makeStyles<Theme>({
   externalLinkIcon: {
@@ -38,6 +38,7 @@ const WidgetContent = ({
 }) => {
   const classes = useStyles();
   if (loading || !lastRun) return <LinearProgress />;
+
   return (
     <StructuredMetadataTable
       metadata={{
@@ -60,20 +61,10 @@ const WidgetContent = ({
   );
 };
 
-export const JenkinsLastBuildWidget = ({
-  entity,
-  branch = 'master',
-}: {
-  entity: Entity;
-  branch: string;
-}) => {
-  const [owner, repo] = (
-    entity?.metadata.annotations?.['backstage.io/jenkins-github-folder'] ?? '/'
-  ).split('/');
-  const [{ loading, value }] = useBuilds(owner, repo, branch);
-
-  const lastRun = value ?? {};
-
+export const LatestRunCard = ({ branch = 'master' }: { branch: string }) => {
+  const { owner, repo } = useProjectSlugFromEntity();
+  const [{ builds, loading }] = useBuilds(owner, repo, branch);
+  const lastRun = builds ?? {};
   return (
     <InfoCard title={`Last ${branch} build`}>
       <WidgetContent loading={loading} branch={branch} lastRun={lastRun} />

plugins/jenkins/src/components/Cards/index.ts

@@ -13,4 +13,4 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export * from './Layout';
+export { LatestRunCard } from './Cards';

plugins/jenkins/src/components/Layout/Layout.tsx

@@ -1,29 +0,0 @@
-/*
- * Copyright 2020 Spotify AB
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import React from 'react';
-import { Header, Page, pageTheme, HeaderLabel } from '@backstage/core';
-
-export const Layout: React.FC = ({ children }) => {
-  return (
-    <Page theme={pageTheme.tool}>
-      <Header title="Jenkins" subtitle="See recent builds and their status">
-        <HeaderLabel label="Owner" value="Spotify" />
-        <HeaderLabel label="Lifecycle" value="Alpha" />
-      </Header>
-      {children}
-    </Page>
-  );
-};

plugins/jenkins/src/components/PluginHeader/PluginHeader.tsx

@@ -1,36 +0,0 @@
-/*
- * Copyright 2020 Spotify AB
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import React from 'react';
-import { ContentHeader, SupportButton } from '@backstage/core';
-import { Box, Typography } from '@material-ui/core';
-
-export type Props = { title?: string };
-export const PluginHeader = ({ title = 'Jenkins' }) => {
-  return (
-    <ContentHeader
-      title={title}
-      titleComponent={() => (
-        <Box alignItems="center" display="flex">
-          <Typography variant="h4">{title}</Typography>
-        </Box>
-      )}
-    >
-      <SupportButton>
-        This plugin allows you to view and interact with your builds in Jenkins.
-      </SupportButton>
-    </ContentHeader>
-  );
-};

plugins/jenkins/src/components/Router.tsx

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2020 Spotify AB
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import React from 'react';
+import { Route, Routes } from 'react-router';
+import { buildRouteRef, rootRouteRef } from '../plugin';
+import { DetailedViewPage } from './BuildWithStepsPage/';
+import { JENKINS_ANNOTATION } from '../constants';
+import { Entity } from '@backstage/catalog-model';
+import { WarningPanel } from '@backstage/core';
+import { CITable } from './BuildsPage/lib/CITable';
+
+export const isPluginApplicableToEntity = (entity: Entity) =>
+  Boolean(entity.metadata.annotations?.[JENKINS_ANNOTATION]) &&
+  entity.metadata.annotations?.[JENKINS_ANNOTATION] !== '';
+
+export const Router = ({ entity }: { entity: Entity }) => {
+  return !isPluginApplicableToEntity(entity) ? (
+    <WarningPanel title="Jenkins plugin:">
+      <pre>entity.metadata.annotations['{JENKINS_ANNOTATION}']</pre>
+      key is missing on the entity.
+    </WarningPanel>
+  ) : (
+    <Routes>
+      <Route path={`/${rootRouteRef.path}`} element={<CITable />} />
+      <Route path={`/${buildRouteRef.path}`} element={<DetailedViewPage />} />
+    </Routes>
+  );
+};

plugins/jenkins/src/components/useBuildWithSteps.ts

@@ -16,7 +16,7 @@
 import { errorApiRef, useApi } from '@backstage/core';
 import { useCallback } from 'react';
 import { useAsyncRetry } from 'react-use';
-import { jenkinsApiRef } from '../api/index';
+import { jenkinsApiRef } from '../api';
 import { useAsyncPolling } from './useAsyncPolling';
 
 const INTERVAL_AMOUNT = 1500;

plugins/jenkins/src/components/useBuilds.ts

@@ -56,8 +56,9 @@ export function useBuilds(owner: string, repo: string, branch?: string) {
     });
   }, [repo, getBuilds]);
 
-  const { loading, value, retry } = useAsyncRetry(
-    () => getBuilds().then(builds => builds ?? [], restartBuild),
+  const { loading, value: builds, retry } = useAsyncRetry(
+    () =>
+      getBuilds().then(retrievedBuilds => retrievedBuilds ?? [], restartBuild),
     [page, pageSize, getBuilds],
   );
 
@@ -67,12 +68,12 @@ export function useBuilds(owner: string, repo: string, branch?: string) {
       page,
       pageSize,
       loading,
-      value,
+      builds,
       projectName,
       total,
     },
     {
-      getBuilds,
+      builds,
       setPage,
       setPageSize,
       restartBuild,

plugins/jenkins/src/components/useProjectSlugFromEntity.ts

@@ -13,15 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { useEntity } from '@backstage/plugin-catalog';
+import { JENKINS_ANNOTATION } from '../constants';
 
-import React from 'react';
-import { Builds } from '../../pages/BuildsPage/lib/Builds';
-import { Entity } from '@backstage/catalog-model';
+export const useProjectSlugFromEntity = () => {
+  const { entity } = useEntity();
 
-export const JenkinsBuildsWidget = ({ entity }: { entity: Entity }) => {
   const [owner, repo] = (
-    entity?.metadata.annotations?.['backstage.io/jenkins-github-folder'] ?? '/'
+    entity.metadata.annotations?.[JENKINS_ANNOTATION] ?? ''
   ).split('/');
-
-  return <Builds owner={owner} repo={repo} />;
+  return { owner, repo };
 };

plugins/jenkins/src/constants.ts

@@ -13,4 +13,4 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export * from './PluginHeader';
+export const JENKINS_ANNOTATION = 'jenkins.io/github-folder';

plugins/jenkins/src/index.ts

@@ -14,5 +14,8 @@
  * limitations under the License.
  */
 
-export { plugin, JenkinsBuildsWidget, JenkinsLastBuildWidget } from './plugin';
+export { plugin } from './plugin';
+export { LatestRunCard } from './components/Cards';
+export { Router, isPluginApplicableToEntity } from './components/Router';
+export { JENKINS_ANNOTATION } from './constants';
 export * from './api';

plugins/jenkins/src/pages/BuildWithStepsPage/BuildWithStepsPage.tsx

@@ -1,164 +0,0 @@
-/*
- * Copyright 2020 Spotify AB
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import React, { FC, useEffect } from 'react';
-import { useSearchParams } from 'react-router-dom';
-import { Content, InfoCard, Progress } from '@backstage/core';
-import { Grid, Box, Link, IconButton } from '@material-ui/core';
-import { makeStyles } from '@material-ui/core/styles';
-import { PluginHeader } from '../../components/PluginHeader';
-import { ActionOutput } from './lib/ActionOutput/ActionOutput';
-import { Layout } from '../../components/Layout';
-import LaunchIcon from '@material-ui/icons/Launch';
-import GitHubIcon from '@material-ui/icons/GitHub';
-import { useBuildWithSteps } from '../../state/useBuildWithSteps';
-
-const IconLink = IconButton as typeof Link;
-const BuildName: FC<{ build?: any }> = ({ build }) => (
-  <Box display="flex" alignItems="center">
-    {build?.buildName}
-    <IconLink href={build?.url} target="_blank" title="View on Jenkins">
-      <LaunchIcon /> {/* TODO use Jenkins logo*/}
-    </IconLink>
-    <IconLink href={build?.source.url} target="_blank" title="View on GitHub">
-      <GitHubIcon />
-    </IconLink>
-  </Box>
-);
-const useStyles = makeStyles(theme => ({
-  neutral: {},
-  failed: {
-    position: 'relative',
-    '&:after': {
-      pointerEvents: 'none',
-      content: '""',
-      position: 'absolute',
-      top: 0,
-      right: 0,
-      left: 0,
-      bottom: 0,
-      boxShadow: `inset 4px 0px 0px ${theme.palette.error.main}`,
-    },
-  },
-  running: {
-    position: 'relative',
-    '&:after': {
-      pointerEvents: 'none',
-      content: '""',
-      position: 'absolute',
-      top: 0,
-      right: 0,
-      left: 0,
-      bottom: 0,
-      boxShadow: `inset 4px 0px 0px ${theme.palette.info.main}`,
-    },
-  },
-  cardContent: {
-    backgroundColor: theme.palette.background.default,
-  },
-  success: {
-    position: 'relative',
-    '&:after': {
-      pointerEvents: 'none',
-      content: '""',
-      position: 'absolute',
-      top: 0,
-      right: 0,
-      left: 0,
-      bottom: 0,
-      boxShadow: `inset 4px 0px 0px ${theme.palette.success.main}`,
-    },
-  },
-}));
-
-const pickClassName = (
-  classes: ReturnType<typeof useStyles>,
-  build: any = {},
-) => {
-  if (build.result === 'UNSTABLE') return classes.failed;
-  if (build.result === 'FAILURE') return classes.failed;
-  if (build.building) return classes.running;
-  if (build.status === 'SUCCESS') return classes.success;
-
-  return classes.neutral;
-};
-
-const Page = () => (
-  <Layout>
-    <Content>
-      <BuildWithStepsView />
-    </Content>
-  </Layout>
-);
-
-const BuildWithStepsView = () => {
-  const [searchParams] = useSearchParams();
-  const buildPath = searchParams.get('url') || '';
-  const classes = useStyles();
-  const [{ loading, value }, { startPolling, stopPolling }] = useBuildWithSteps(
-    buildPath,
-  );
-
-  useEffect(() => {
-    startPolling();
-    return () => stopPolling();
-  }, [buildPath, startPolling, stopPolling]);
-  return (
-    <>
-      <PluginHeader title={value?.source.displayName || 'Build details'} />
-
-      <Grid container spacing={3} direction="column">
-        <Grid item>
-          <InfoCard
-            className={pickClassName(classes, value)}
-            title={<BuildName build={value} />}
-            cardClassName={classes.cardContent}
-          >
-            {loading ? <Progress /> : <BuildsList build={value} />}
-          </InfoCard>
-        </Grid>
-      </Grid>
-    </>
-  );
-};
-
-const BuildsList: FC<{ build?: any }> = ({ build }) => (
-  <Box>
-    {build &&
-      build.steps &&
-      build.steps.map(({ name, actions }: { name: string; actions: any[] }) => (
-        <ActionsList name={name} actions={actions} />
-      ))}
-  </Box>
-);
-
-const ActionsList: FC<{ actions: any[]; name: string }> = ({ actions }) => {
-  const classes = useStyles();
-  return (
-    <>
-      {actions.map((action: any) => (
-        <ActionOutput
-          className={action.failed ? classes.failed : classes.success}
-          action={action}
-          name={action.name}
-          url={action.output_url || ''}
-        />
-      ))}
-    </>
-  );
-};
-
-export default Page;
-export { BuildWithStepsView as BuildWithSteps };

plugins/jenkins/src/pages/BuildsPage/lib/Builds/Builds.tsx

@@ -1,38 +0,0 @@
-/*
- * Copyright 2020 Spotify AB
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import React from 'react';
-import { CITable } from '../CITable';
-import { useBuilds } from '../../../../state';
-
-export const Builds = ({ owner, repo }: { owner: string; repo: string }) => {
-  const [
-    { total, loading, value, projectName, page, pageSize },
-    { setPage, retry, setPageSize },
-  ] = useBuilds(owner, repo);
-  return (
-    <CITable
-      total={total}
-      loading={loading}
-      retry={retry}
-      builds={value ?? []}
-      projectName={projectName}
-      page={page}
-      onChangePage={setPage}
-      pageSize={pageSize}
-      onChangePageSize={setPageSize}
-    />
-  );
-};

plugins/jenkins/src/pages/BuildsPage/lib/Builds/index.ts

@@ -1,16 +0,0 @@
-/*
- * Copyright 2020 Spotify AB
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-export { Builds } from './Builds';

plugins/jenkins/src/plugin.ts

@@ -20,11 +20,15 @@ import {
   createApiFactory,
   configApiRef,
 } from '@backstage/core';
-import { DetailedViewPage } from './pages/BuildWithStepsPage';
 import { jenkinsApiRef, JenkinsApi } from './api';
 
+export const rootRouteRef = createRouteRef({
+  path: '',
+  title: 'Jenkins',
+});
+
 export const buildRouteRef = createRouteRef({
-  path: '/jenkins/job',
+  path: 'run/:branch/:buildNumber',
   title: 'Jenkins run',
 });
 
@@ -40,10 +44,4 @@ export const plugin = createPlugin({
         ),
     }),
   ],
-  register({ router }) {
-    router.addRoute(buildRouteRef, DetailedViewPage);
-  },
 });
-
-export { JenkinsBuildsWidget } from './components/JenkinsPluginWidget/JenkinsBuildsWidget';
-export { JenkinsLastBuildWidget } from './components/JenkinsPluginWidget/JenkinsLastBuildWidget';

plugins/jenkins/src/state/index.ts

@@ -1,17 +0,0 @@
-/*
- * Copyright 2020 Spotify AB
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-export * from './useBuilds';
-export * from './useBuildWithSteps';

plugins/scaffolder-backend/package.json

@@ -23,6 +23,8 @@
     "@backstage/backend-common": "^0.1.1-alpha.21",
     "@backstage/catalog-model": "^0.1.1-alpha.21",
     "@backstage/config": "^0.1.1-alpha.21",
+    "@gitbeaker/core": "^23.5.0",
+    "@gitbeaker/node": "^23.5.0",
     "@octokit/rest": "^18.0.0",
     "@types/dockerode": "^2.5.32",
     "@types/express": "^4.17.6",
@@ -33,11 +35,12 @@
     "express": "^4.17.1",
     "express-promise-router": "^3.0.3",
     "fs-extra": "^9.0.0",
-    "git-url-parse": "^11.1.2",
+    "git-url-parse": "^11.2.0",
     "globby": "^11.0.0",
     "helmet": "^4.0.0",
+    "jsonschema": "^1.2.6",
     "morgan": "^1.10.0",
-    "nodegit": "0.26.5",
+    "nodegit": "0.27.0",
     "uuid": "^8.2.0",
     "winston": "^3.2.1",
     "yaml": "^1.10.0"

plugins/scaffolder-backend/sample-templates/docs-template/template.yaml

@@ -17,6 +17,7 @@ spec:
   schema:
     required: 
       - component_id
+      - description
     properties:
       component_id:
         title: Name

plugins/scaffolder-backend/src/scaffolder/__mocks__/@gitbeaker/node/index.ts

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2020 Spotify AB
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export const mockGitlabClient = {
+  Namespaces: {
+    show: jest.fn(),
+  },
+  Projects: {
+    create: jest.fn(),
+  },
+  Users: {
+    current: jest.fn(),
+  },
+};
+
+export class Gitlab {
+  constructor() {
+    return mockGitlabClient;
+  }
+}

plugins/scaffolder-backend/src/scaffolder/__mocks__/@octokit/rest/index.ts

@@ -18,10 +18,14 @@ export const mockGithubClient = {
   repos: {
     createInOrg: jest.fn(),
     createForAuthenticatedUser: jest.fn(),
+    addCollaborator: jest.fn(),
   },
   users: {
     getByUsername: jest.fn(),
   },
+  teams: {
+    addOrUpdateRepoPermissionsInOrg: jest.fn(),
+  },
 };
 
 export class Octokit {

plugins/scaffolder-backend/src/scaffolder/stages/index.ts

@@ -16,3 +16,4 @@
 export * from './prepare';
 export * from './publish';
 export * from './templater';
+export * from './helpers';

plugins/scaffolder-backend/src/scaffolder/stages/prepare/file.ts

@@ -17,7 +17,7 @@ import fs from 'fs-extra';
 import path from 'path';
 import os from 'os';
 import { TemplateEntityV1alpha1 } from '@backstage/catalog-model';
-import { parseLocationAnnotation } from './helpers';
+import { parseLocationAnnotation } from '../helpers';
 import { InputError } from '@backstage/backend-common';
 import { PreparerBase } from './types';
 

plugins/scaffolder-backend/src/scaffolder/stages/prepare/github.ts

@@ -17,7 +17,7 @@ import fs from 'fs-extra';
 import path from 'path';
 import os from 'os';
 import { TemplateEntityV1alpha1 } from '@backstage/catalog-model';
-import { parseLocationAnnotation } from './helpers';
+import { parseLocationAnnotation } from '../helpers';
 import { InputError } from '@backstage/backend-common';
 import { PreparerBase } from './types';
 import GitUriParser from 'git-url-parse';

plugins/scaffolder-backend/src/scaffolder/stages/prepare/gitlab.test.ts

@@ -0,0 +1,143 @@
+/*
+ * Copyright 2020 Spotify AB
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const mocks = {
+  Clone: { clone: jest.fn() },
+  CheckoutOptions: jest.fn(() => {}),
+};
+jest.doMock('nodegit', () => mocks);
+
+import { GitlabPreparer } from './gitlab';
+import {
+  TemplateEntityV1alpha1,
+  LOCATION_ANNOTATION,
+} from '@backstage/catalog-model';
+import { ConfigReader } from '@backstage/config';
+
+const mockEntityWithProtocol = (protocol: string): TemplateEntityV1alpha1 => ({
+  apiVersion: 'backstage.io/v1alpha1',
+  kind: 'Template',
+  metadata: {
+    annotations: {
+      [LOCATION_ANNOTATION]: `${protocol}:https://gitlab.com/benjdlambert/backstage-graphql-template/-/blob/master/template.yaml`,
+    },
+    name: 'graphql-starter',
+    title: 'GraphQL Service',
+    description:
+      'A GraphQL starter template for backstage to get you up and running\nthe best pracices with GraphQL\n',
+    uid: '9cf16bad-16e0-4213-b314-c4eec773c50b',
+    etag: 'ZTkxMjUxMjUtYWY3Yi00MjU2LWFkYWMtZTZjNjU5ZjJhOWM2',
+    generation: 1,
+  },
+  spec: {
+    type: 'website',
+    templater: 'cookiecutter',
+    path: './template',
+    schema: {
+      $schema: 'http://json-schema.org/draft-07/schema#',
+      required: ['storePath', 'owner'],
+      properties: {
+        owner: {
+          type: 'string',
+          title: 'Owner',
+          description: 'Who is going to own this component',
+        },
+        storePath: {
+          type: 'string',
+          title: 'Store path',
+          description: 'GitHub store path in org/repo format',
+        },
+      },
+    },
+  },
+});
+
+describe('GitLabPreparer', () => {
+  let mockEntity: TemplateEntityV1alpha1;
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  ['gitlab', 'gitlab/api'].forEach(protocol => {
+    it(`calls the clone command with the correct arguments for a repository using the ${protocol} protocol`, async () => {
+      const preparer = new GitlabPreparer(ConfigReader.fromConfigs([]));
+      mockEntity = mockEntityWithProtocol(protocol);
+      await preparer.prepare(mockEntity);
+      expect(mocks.Clone.clone).toHaveBeenNthCalledWith(
+        1,
+        'https://gitlab.com/benjdlambert/backstage-graphql-template',
+        expect.any(String),
+        {},
+      );
+    });
+
+    it(`calls the clone command with the correct arguments if an access token is provided for a repository using the ${protocol} protocol`, async () => {
+      const preparer = new GitlabPreparer(
+        ConfigReader.fromConfigs([
+          {
+            context: '',
+            data: {
+              catalog: {
+                processors: {
+                  gitlabApi: {
+                    privateToken: 'fake-token',
+                  },
+                },
+              },
+            },
+          },
+        ]),
+      );
+      mockEntity = mockEntityWithProtocol(protocol);
+      await preparer.prepare(mockEntity);
+      expect(mocks.Clone.clone).toHaveBeenNthCalledWith(
+        1,
+        'https://gitlab.com/benjdlambert/backstage-graphql-template',
+        expect.any(String),
+        {
+          fetchOpts: {
+            callbacks: {
+              credentials: expect.anything(),
+            },
+          },
+        },
+      );
+    });
+
+    it(`calls the clone command with the correct arguments for a repository when no path is provided using the ${protocol} protocol`, async () => {
+      const preparer = new GitlabPreparer(ConfigReader.fromConfigs([]));
+      mockEntity = mockEntityWithProtocol(protocol);
+      delete mockEntity.spec.path;
+      await preparer.prepare(mockEntity);
+      expect(mocks.Clone.clone).toHaveBeenNthCalledWith(
+        1,
+        'https://gitlab.com/benjdlambert/backstage-graphql-template',
+        expect.any(String),
+        {},
+      );
+    });
+
+    it(`return the temp directory with the path to the folder if it is specified using the ${protocol} protocol`, async () => {
+      const preparer = new GitlabPreparer(ConfigReader.fromConfigs([]));
+      mockEntity = mockEntityWithProtocol(protocol);
+      mockEntity.spec.path = './template/test/1/2/3';
+      const response = await preparer.prepare(mockEntity);
+
+      expect(response.split('\\').join('/')).toMatch(
+        /\/template\/test\/1\/2\/3$/,
+      );
+    });
+  });
+});

plugins/scaffolder-backend/src/scaffolder/stages/prepare/gitlab.ts

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2020 Spotify AB
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { TemplateEntityV1alpha1 } from '@backstage/catalog-model';
+import { parseLocationAnnotation } from '../helpers';
+import { InputError } from '@backstage/backend-common';
+import { PreparerBase } from './types';
+import GitUriParser from 'git-url-parse';
+import { Clone, Cred } from 'nodegit';
+import { Config } from '@backstage/config';
+
+export class GitlabPreparer implements PreparerBase {
+  private readonly privateToken: string;
+
+  constructor(config: Config) {
+    this.privateToken =
+      config.getOptionalString('catalog.processors.gitlabApi.privateToken') ??
+      '';
+  }
+
+  async prepare(template: TemplateEntityV1alpha1): Promise<string> {
+    const { protocol, location } = parseLocationAnnotation(template);
+
+    if (['gitlab', 'gitlab/api'].indexOf(protocol) < 0) {
+      throw new InputError(
+        `Wrong location protocol: ${protocol}, should be 'gitlab' or 'gitlab/api'`,
+      );
+    }
+    const templateId = template.metadata.name;
+
+    const parsedGitLocation = GitUriParser(location);
+    const repositoryCheckoutUrl = parsedGitLocation.toString('https');
+
+    const tempDir = await fs.promises.mkdtemp(
+      path.join(os.tmpdir(), templateId),
+    );
+
+    const templateDirectory = path.join(
+      `${path.dirname(parsedGitLocation.filepath)}`,
+      template.spec.path ?? '.',
+    );
+
+    const options = this.privateToken
+      ? {
+          fetchOpts: {
+            callbacks: {
+              credentials: () =>
+                Cred.userpassPlaintextNew('oauth2', this.privateToken),
+            },
+          },
+        }
+      : {};
+
+    await Clone.clone(repositoryCheckoutUrl, tempDir, options);
+
+    return path.resolve(tempDir, templateDirectory);
+  }
+}

plugins/scaffolder-backend/src/scaffolder/stages/prepare/index.ts

@@ -15,6 +15,6 @@
  */
 export * from './preparers';
 export * from './types';
-export * from './helpers';
 export * from './file';
 export * from './github';
+export * from './gitlab';

plugins/scaffolder-backend/src/scaffolder/stages/prepare/preparers.ts

@@ -14,9 +14,10 @@
  * limitations under the License.
  */
 
-import { PreparerBase, RemoteProtocol, PreparerBuilder } from './types';
+import { PreparerBase, PreparerBuilder } from './types';
 import { TemplateEntityV1alpha1 } from '@backstage/catalog-model';
-import { parseLocationAnnotation } from './helpers';
+import { parseLocationAnnotation } from '../helpers';
+import { RemoteProtocol } from '../types';
 
 export class Preparers implements PreparerBuilder {
   private preparerMap = new Map<RemoteProtocol, PreparerBase>();

plugins/scaffolder-backend/src/scaffolder/stages/prepare/types.ts

@@ -15,6 +15,7 @@
  */
 import type { TemplateEntityV1alpha1 } from '@backstage/catalog-model';
 import { Logger } from 'winston';
+import { RemoteProtocol } from '../types';
 
 export type PreparerBase = {
   /**
@@ -32,5 +33,3 @@ export type PreparerBuilder = {
   register(protocol: RemoteProtocol, preparer: PreparerBase): void;
   get(template: TemplateEntityV1alpha1): PreparerBase;
 };
-
-export type RemoteProtocol = 'file' | 'github';

plugins/scaffolder-backend/src/scaffolder/stages/publish/github.test.ts

@@ -30,6 +30,7 @@ const { mockGithubClient } = require('@octokit/rest') as {
   mockGithubClient: {
     repos: jest.Mocked<Octokit['repos']>;
     users: jest.Mocked<Octokit['users']>;
+    teams: jest.Mocked<Octokit['teams']>;
   };
 };
 
@@ -53,14 +54,235 @@ const {
 };
 
 describe('GitHub Publisher', () => {
-  const publisher = new GithubPublisher({ client: new Octokit() });
-
   beforeEach(() => {
     jest.clearAllMocks();
   });
 
-  describe('publish: createRemoteInGithub', () => {
-    it('should use octokit to create a repo in an organisation if the organisation property is set', async () => {
+  describe('with public repo visibility', () => {
+    const publisher = new GithubPublisher({
+      client: new Octokit(),
+      token: 'abc',
+      repoVisibility: 'public',
+    });
+
+    describe('publish: createRemoteInGithub', () => {
+      it('should use octokit to create a repo in an organisation if the organisation property is set', async () => {
+        mockGithubClient.repos.createInOrg.mockResolvedValue({
+          data: {
+            clone_url: 'mockclone',
+          },
+        } as OctokitResponse<ReposCreateInOrgResponseData>);
+
+        await publisher.publish({
+          values: {
+            storePath: 'blam/test',
+            owner: 'bob',
+            access: 'blam/team',
+          },
+          directory: '/tmp/test',
+        });
+
+        expect(mockGithubClient.repos.createInOrg).toHaveBeenCalledWith({
+          org: 'blam',
+          name: 'test',
+          private: false,
+          visibility: 'public',
+        });
+        expect(
+          mockGithubClient.teams.addOrUpdateRepoPermissionsInOrg,
+        ).toHaveBeenCalledWith({
+          org: 'blam',
+          team_slug: 'team',
+          owner: 'blam',
+          repo: 'test',
+          permission: 'admin',
+        });
+      });
+
+      it('should use octokit to create a repo in the authed user if the organisation property is not set', async () => {
+        mockGithubClient.repos.createForAuthenticatedUser.mockResolvedValue({
+          data: {
+            clone_url: 'mockclone',
+          },
+        } as OctokitResponse<ReposCreateInOrgResponseData>);
+        mockGithubClient.users.getByUsername.mockResolvedValue({
+          data: {
+            type: 'User',
+          },
+        } as OctokitResponse<UsersGetByUsernameResponseData>);
+
+        await publisher.publish({
+          values: {
+            storePath: 'blam/test',
+            owner: 'bob',
+            access: 'blam',
+          },
+          directory: '/tmp/test',
+        });
+
+        expect(
+          mockGithubClient.repos.createForAuthenticatedUser,
+        ).toHaveBeenCalledWith({
+          name: 'test',
+          private: false,
+        });
+        expect(mockGithubClient.repos.addCollaborator).not.toHaveBeenCalled();
+      });
+    });
+
+    it('should invite other user in the authed user', async () => {
+      mockGithubClient.repos.createForAuthenticatedUser.mockResolvedValue({
+        data: {
+          clone_url: 'mockclone',
+        },
+      } as OctokitResponse<ReposCreateInOrgResponseData>);
+      mockGithubClient.users.getByUsername.mockResolvedValue({
+        data: {
+          type: 'User',
+        },
+      } as OctokitResponse<UsersGetByUsernameResponseData>);
+
+      await publisher.publish({
+        values: {
+          storePath: 'blam/test',
+          owner: 'bob',
+          access: 'bob',
+          description: 'description',
+        },
+        directory: '/tmp/test',
+      });
+
+      expect(
+        mockGithubClient.repos.createForAuthenticatedUser,
+      ).toHaveBeenCalledWith({
+        description: 'description',
+        name: 'test',
+        private: false,
+      });
+      expect(mockGithubClient.repos.addCollaborator).toHaveBeenCalledWith({
+        owner: 'blam',
+        repo: 'test',
+        username: 'bob',
+        permission: 'admin',
+      });
+    });
+
+    describe('publish: createGitDirectory', () => {
+      const values = {
+        storePath: 'blam/test',
+        owner: 'lols',
+        access: 'lols',
+      };
+
+      const mockDir = '/tmp/test/dir';
+
+      mockGithubClient.repos.createInOrg.mockResolvedValue({
+        data: {
+          clone_url: 'mockclone',
+        },
+      } as OctokitResponse<ReposCreateInOrgResponseData>);
+      mockGithubClient.users.getByUsername.mockResolvedValue({
+        data: {
+          type: 'Organization',
+        },
+      } as OctokitResponse<UsersGetByUsernameResponseData>);
+
+      it('should call init on the repo with the directory', async () => {
+        await publisher.publish({
+          values,
+          directory: mockDir,
+        });
+
+        expect(Repository.init).toHaveBeenCalledWith(mockDir, 0);
+      });
+
+      it('should call refresh index on the index and write the new files', async () => {
+        await publisher.publish({
+          values,
+          directory: mockDir,
+        });
+
+        expect(mockRepo.refreshIndex).toHaveBeenCalled();
+      });
+
+      it('should call add all files and write', async () => {
+        await publisher.publish({
+          values,
+          directory: mockDir,
+        });
+
+        expect(mockIndex.addAll).toHaveBeenCalled();
+        expect(mockIndex.write).toHaveBeenCalled();
+        expect(mockIndex.writeTree).toHaveBeenCalled();
+      });
+
+      it('should create a commit with on head with the right name and commiter', async () => {
+        const mockSignature = { mockSignature: 'bloblly' };
+        Signature.now.mockReturnValue(mockSignature);
+
+        await publisher.publish({
+          values,
+          directory: mockDir,
+        });
+
+        expect(Signature.now).toHaveBeenCalledTimes(2);
+        expect(Signature.now).toHaveBeenCalledWith(
+          'Scaffolder',
+          'scaffolder@backstage.io',
+        );
+
+        expect(mockRepo.createCommit).toHaveBeenCalledWith(
+          'HEAD',
+          mockSignature,
+          mockSignature,
+          'initial commit',
+          'mockoid',
+          [],
+        );
+      });
+
+      it('creates a remote with the repo and remote', async () => {
+        await publisher.publish({
+          values,
+          directory: mockDir,
+        });
+
+        expect(Remote.create).toHaveBeenCalledWith(
+          mockRepo,
+          'origin',
+          'mockclone',
+        );
+      });
+
+      it('shoud push to the remote repo', async () => {
+        await publisher.publish({
+          values,
+          directory: mockDir,
+        });
+
+        const [remotes, { callbacks }] = mockRemote.push.mock
+          .calls[0] as NodeGit.PushOptions[];
+
+        expect(remotes).toEqual(['refs/heads/master:refs/heads/master']);
+
+        callbacks?.credentials?.();
+
+        expect(Cred.userpassPlaintextNew).toHaveBeenCalledWith(
+          'abc',
+          'x-oauth-basic',
+        );
+      });
+    });
+  });
+
+  describe('with internal repo visibility', () => {
+    const publisher = new GithubPublisher({
+      client: new Octokit(),
+      token: 'abc',
+      repoVisibility: 'internal',
+    });
+
+    it('creates a private repository in the organization with visibility set to internal', async () => {
       mockGithubClient.repos.createInOrg.mockResolvedValue({
         data: {
           clone_url: 'mockclone',
@@ -74,6 +296,7 @@ describe('GitHub Publisher', () => {
 
       await publisher.publish({
         values: {
+          isOrg: true,
           storePath: 'blam/test',
           owner: 'bob',
         },
@@ -83,10 +306,20 @@ describe('GitHub Publisher', () => {
       expect(mockGithubClient.repos.createInOrg).toHaveBeenCalledWith({
         org: 'blam',
         name: 'test',
+        private: true,
+        visibility: 'internal',
       });
     });
+  });
 
-    it('should use octokit to create a repo in the authed user if the organisation property is not set', async () => {
+  describe('private visibility in a user account', () => {
+    const publisher = new GithubPublisher({
+      client: new Octokit(),
+      token: 'abc',
+      repoVisibility: 'private',
+    });
+
+    it('creates a private repository', async () => {
       mockGithubClient.repos.createForAuthenticatedUser.mockResolvedValue({
         data: {
           clone_url: 'mockclone',
@@ -110,116 +343,8 @@ describe('GitHub Publisher', () => {
         mockGithubClient.repos.createForAuthenticatedUser,
       ).toHaveBeenCalledWith({
         name: 'test',
+        private: true,
       });
     });
   });
-
-  describe('publish: createGitDirectory', () => {
-    const values = {
-      isOrg: true,
-      storePath: 'blam/test',
-      owner: 'lols',
-    };
-
-    const mockDir = '/tmp/test/dir';
-
-    mockGithubClient.repos.createInOrg.mockResolvedValue({
-      data: {
-        clone_url: 'mockclone',
-      },
-    } as OctokitResponse<ReposCreateInOrgResponseData>);
-    mockGithubClient.users.getByUsername.mockResolvedValue({
-      data: {
-        type: 'Organization',
-      },
-    } as OctokitResponse<UsersGetByUsernameResponseData>);
-
-    it('should call init on the repo with the directory', async () => {
-      await publisher.publish({
-        values,
-        directory: mockDir,
-      });
-
-      expect(Repository.init).toHaveBeenCalledWith(mockDir, 0);
-    });
-
-    it('should call refresh index on the index and write the new files', async () => {
-      await publisher.publish({
-        values,
-        directory: mockDir,
-      });
-
-      expect(mockRepo.refreshIndex).toHaveBeenCalled();
-    });
-
-    it('should call add all files and write', async () => {
-      await publisher.publish({
-        values,
-        directory: mockDir,
-      });
-
-      expect(mockIndex.addAll).toHaveBeenCalled();
-      expect(mockIndex.write).toHaveBeenCalled();
-      expect(mockIndex.writeTree).toHaveBeenCalled();
-    });
-
-    it('should create a commit with on head with the right name and commiter', async () => {
-      const mockSignature = { mockSignature: 'bloblly' };
-      Signature.now.mockReturnValue(mockSignature);
-
-      await publisher.publish({
-        values,
-        directory: mockDir,
-      });
-
-      expect(Signature.now).toHaveBeenCalledTimes(2);
-      expect(Signature.now).toHaveBeenCalledWith(
-        'Scaffolder',
-        'scaffolder@backstage.io',
-      );
-
-      expect(mockRepo.createCommit).toHaveBeenCalledWith(
-        'HEAD',
-        mockSignature,
-        mockSignature,
-        'initial commit',
-        'mockoid',
-        [],
-      );
-    });
-
-    it('creates a remote with the repo and remote', async () => {
-      await publisher.publish({
-        values,
-        directory: mockDir,
-      });
-
-      expect(Remote.create).toHaveBeenCalledWith(
-        mockRepo,
-        'origin',
-        'mockclone',
-      );
-    });
-
-    it('shoud push to the remote repo', async () => {
-      await publisher.publish({
-        values,
-        directory: mockDir,
-      });
-
-      const [remotes, { callbacks }] = mockRemote.push.mock
-        .calls[0] as NodeGit.PushOptions[];
-
-      expect(remotes).toEqual(['refs/heads/master:refs/heads/master']);
-
-      process.env.GITHUb_ACCESS_TOKEN = 'blob';
-
-      callbacks?.credentials?.();
-
-      expect(Cred.userpassPlaintextNew).toHaveBeenCalledWith(
-        process.env.GITHUB_ACCESS_TOKEN,
-        'x-oauth-basic',
-      );
-    });
-  });
 });

plugins/scaffolder-backend/src/scaffolder/stages/publish/github.ts

@@ -21,10 +21,27 @@ import { JsonValue } from '@backstage/config';
 import { RequiredTemplateValues } from '../templater';
 import { Repository, Remote, Signature, Cred } from 'nodegit';
 
+export type RepoVisilityOptions = 'private' | 'internal' | 'public';
+
+interface GithubPublisherParams {
+  client: Octokit;
+  token: string;
+  repoVisibility: RepoVisilityOptions;
+}
+
 export class GithubPublisher implements PublisherBase {
   private client: Octokit;
-  constructor({ client }: { client: Octokit }) {
+  private token: string;
+  private repoVisibility: RepoVisilityOptions;
+
+  constructor({
+    client,
+    token,
+    repoVisibility = 'public',
+  }: GithubPublisherParams) {
     this.client = client;
+    this.token = token;
+    this.repoVisibility = repoVisibility;
   }
 
   async publish({
@@ -44,16 +61,47 @@ export class GithubPublisher implements PublisherBase {
     values: RequiredTemplateValues & Record<string, JsonValue>,
   ) {
     const [owner, name] = values.storePath.split('/');
+    const description = values.description as string;
 
     const user = await this.client.users.getByUsername({ username: owner });
 
     const repoCreationPromise =
       user.data.type === 'Organization'
-        ? this.client.repos.createInOrg({ name, org: owner })
-        : this.client.repos.createForAuthenticatedUser({ name });
+        ? this.client.repos.createInOrg({
+            name,
+            org: owner,
+            private: this.repoVisibility !== 'public',
+            visibility: this.repoVisibility,
+            description,
+          })
+        : this.client.repos.createForAuthenticatedUser({
+            name,
+            private: this.repoVisibility === 'private',
+            description,
+          });
 
     const { data } = await repoCreationPromise;
 
+    const access = values.access as string;
+    if (access?.startsWith(`${owner}/`)) {
+      const [, team] = access.split('/');
+      await this.client.teams.addOrUpdateRepoPermissionsInOrg({
+        org: owner,
+        team_slug: team,
+        owner,
+        repo: name,
+        permission: 'admin',
+      });
+      // no need to add access if it's the person who own's the personal account
+    } else if (access && access !== owner) {
+      await this.client.repos.addCollaborator({
+        owner,
+        repo: name,
+        username: access,
+        permission: 'admin',
+      });
+    }
+
     return data?.clone_url;
   }
 
@@ -76,10 +124,7 @@ export class GithubPublisher implements PublisherBase {
     await remoteRepo.push(['refs/heads/master:refs/heads/master'], {
       callbacks: {
         credentials: () => {
-          return Cred.userpassPlaintextNew(
-            process.env.GITHUB_ACCESS_TOKEN as string,
-            'x-oauth-basic',
-          );
+          return Cred.userpassPlaintextNew(this.token, 'x-oauth-basic');
         },
       },
     });

plugins/scaffolder-backend/src/scaffolder/stages/publish/gitlab.test.ts

@@ -0,0 +1,205 @@
+/*
+ * Copyright 2020 Spotify AB
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+jest.mock('nodegit');
+jest.mock('@gitbeaker/node');
+
+import { GitlabPublisher } from './gitlab';
+import { Gitlab as GitlabAPI } from '@gitbeaker/core';
+import { Gitlab } from '@gitbeaker/node';
+import * as NodeGit from 'nodegit';
+
+const { mockGitlabClient } = require('@gitbeaker/node') as {
+  mockGitlabClient: {
+    Namespaces: jest.Mocked<GitlabAPI['Namespaces']>;
+    Projects: jest.Mocked<GitlabAPI['Projects']>;
+    Users: jest.Mocked<GitlabAPI['Users']>;
+  };
+};
+
+const {
+  Repository,
+  mockRepo,
+  mockIndex,
+  Signature,
+  Remote,
+  mockRemote,
+  Cred,
+} = require('nodegit') as {
+  Repository: jest.Mocked<{ init: any }>;
+  Signature: jest.Mocked<{ now: any }>;
+  Cred: jest.Mocked<{ userpassPlaintextNew: any }>;
+  Remote: jest.Mocked<{ create: any }>;
+
+  mockIndex: jest.Mocked<NodeGit.Index>;
+  mockRepo: jest.Mocked<NodeGit.Repository>;
+  mockRemote: jest.Mocked<NodeGit.Remote>;
+};
+
+describe('GitLab Publisher', () => {
+  const publisher = new GitlabPublisher(new Gitlab({}), 'fake-token');
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('publish: createRemoteInGitLab', () => {
+    it('should use gitbeaker to create a repo in a namespace if the namespace property is set', async () => {
+      mockGitlabClient.Namespaces.show.mockResolvedValue({
+        id: 42,
+      } as { id: number });
+
+      await publisher.publish({
+        values: {
+          isOrg: true,
+          storePath: 'blam/test',
+          owner: 'bob',
+        },
+        directory: '/tmp/test',
+      });
+
+      expect(mockGitlabClient.Projects.create).toHaveBeenCalledWith({
+        namespace_id: 42,
+        name: 'test',
+      });
+    });
+
+    it('should use gitbeaker to create a repo in the authed user if the namespace property is not set', async () => {
+      mockGitlabClient.Namespaces.show.mockResolvedValue({});
+      mockGitlabClient.Users.current.mockResolvedValue({
+        id: 21,
+      } as { id: number });
+      mockGitlabClient.Projects.create.mockResolvedValue({
+        http_url_to_repo: 'mockclone',
+      } as { http_url_to_repo: string });
+
+      await publisher.publish({
+        values: {
+          storePath: 'blam/test',
+          owner: 'bob',
+        },
+        directory: '/tmp/test',
+      });
+
+      expect(mockGitlabClient.Users.current).toHaveBeenCalled();
+
+      expect(mockGitlabClient.Projects.create).toHaveBeenCalledWith({
+        namespace_id: 21,
+        name: 'test',
+      });
+    });
+  });
+
+  describe('publish: createGitDirectory', () => {
+    const values = {
+      isOrg: true,
+      storePath: 'blam/test',
+      owner: 'lols',
+    };
+
+    const mockDir = '/tmp/test/dir';
+
+    mockGitlabClient.Projects.create.mockResolvedValue({
+      http_url_to_repo: 'mockclone',
+    } as { http_url_to_repo: string });
+
+    it('should call init on the repo with the directory', async () => {
+      await publisher.publish({
+        values,
+        directory: mockDir,
+      });
+
+      expect(Repository.init).toHaveBeenCalledWith(mockDir, 0);
+    });
+
+    it('should call refresh index on the index and write the new files', async () => {
+      await publisher.publish({
+        values,
+        directory: mockDir,
+      });
+
+      expect(mockRepo.refreshIndex).toHaveBeenCalled();
+    });
+
+    it('should call add all files and write', async () => {
+      await publisher.publish({
+        values,
+        directory: mockDir,
+      });
+
+      expect(mockIndex.addAll).toHaveBeenCalled();
+      expect(mockIndex.write).toHaveBeenCalled();
+      expect(mockIndex.writeTree).toHaveBeenCalled();
+    });
+
+    it('should create a commit with on head with the right name and commiter', async () => {
+      const mockSignature = { mockSignature: 'bloblly' };
+      Signature.now.mockReturnValue(mockSignature);
+
+      await publisher.publish({
+        values,
+        directory: mockDir,
+      });
+
+      expect(Signature.now).toHaveBeenCalledTimes(2);
+      expect(Signature.now).toHaveBeenCalledWith(
+        'Scaffolder',
+        'scaffolder@backstage.io',
+      );
+
+      expect(mockRepo.createCommit).toHaveBeenCalledWith(
+        'HEAD',
+        mockSignature,
+        mockSignature,
+        'initial commit',
+        'mockoid',
+        [],
+      );
+    });
+
+    it('creates a remote with the repo and remote', async () => {
+      await publisher.publish({
+        values,
+        directory: mockDir,
+      });
+
+      expect(Remote.create).toHaveBeenCalledWith(
+        mockRepo,
+        'origin',
+        'mockclone',
+      );
+    });
+
+    it('shoud push to the remote repo', async () => {
+      await publisher.publish({
+        values,
+        directory: mockDir,
+      });
+
+      const [remotes, { callbacks }] = mockRemote.push.mock
+        .calls[0] as NodeGit.PushOptions[];
+
+      expect(remotes).toEqual(['refs/heads/master:refs/heads/master']);
+
+      callbacks?.credentials?.();
+
+      expect(Cred.userpassPlaintextNew).toHaveBeenCalledWith(
+        'oauth2',
+        'fake-token',
+      );
+    });
+  });
+});

plugins/scaffolder-backend/src/scaffolder/stages/publish/gitlab.ts

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2020 Spotify AB
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { PublisherBase } from './types';
+import { Gitlab } from '@gitbeaker/core';
+
+import { JsonValue } from '@backstage/config';
+import { RequiredTemplateValues } from '../templater';
+import { Repository, Remote, Signature, Cred } from 'nodegit';
+
+export class GitlabPublisher implements PublisherBase {
+  private readonly client: Gitlab;
+  private readonly token: string;
+
+  constructor(client: Gitlab, token: string) {
+    this.client = client;
+    this.token = token;
+  }
+
+  async publish({
+    values,
+    directory,
+  }: {
+    values: RequiredTemplateValues & Record<string, JsonValue>;
+    directory: string;
+  }): Promise<{ remoteUrl: string }> {
+    const remoteUrl = await this.createRemote(values);
+    await this.pushToRemote(directory, remoteUrl);
+
+    return { remoteUrl };
+  }
+
+  private async createRemote(
+    values: RequiredTemplateValues & Record<string, JsonValue>,
+  ) {
+    const [owner, name] = values.storePath.split('/');
+
+    let targetNamespace = ((await this.client.Namespaces.show(owner)) as {
+      id: number;
+    }).id;
+    if (!targetNamespace) {
+      targetNamespace = ((await this.client.Users.current()) as { id: number })
+        .id;
+    }
+
+    const project = (await this.client.Projects.create({
+      namespace_id: targetNamespace,
+      name: name,
+    })) as { http_url_to_repo: string };
+
+    return project?.http_url_to_repo;
+  }
+
+  private async pushToRemote(directory: string, remote: string): Promise<void> {
+    const repo = await Repository.init(directory, 0);
+    const index = await repo.refreshIndex();
+    await index.addAll();
+    await index.write();
+    const oid = await index.writeTree();
+    await repo.createCommit(
+      'HEAD',
+      Signature.now('Scaffolder', 'scaffolder@backstage.io'),
+      Signature.now('Scaffolder', 'scaffolder@backstage.io'),
+      'initial commit',
+      oid,
+      [],
+    );
+
+    const remoteRepo = await Remote.create(repo, 'origin', remote);
+
+    await remoteRepo.push(['refs/heads/master:refs/heads/master'], {
+      callbacks: {
+        credentials: () => Cred.userpassPlaintextNew('oauth2', this.token),
+      },
+    });
+  }
+}

plugins/scaffolder-backend/src/scaffolder/stages/publish/index.ts

@@ -13,5 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+export * from './publishers';
 export * from './github';
+export * from './gitlab';
 export * from './types';

plugins/scaffolder-backend/src/scaffolder/stages/publish/publishers.test.ts

@@ -0,0 +1,133 @@
+/*
+ * Copyright 2020 Spotify AB
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Publishers } from './publishers';
+import {
+  LOCATION_ANNOTATION,
+  TemplateEntityV1alpha1,
+} from '@backstage/catalog-model';
+import { GithubPublisher } from './github';
+import { Octokit } from '@octokit/rest';
+
+jest.mock('@octokit/rest');
+
+describe('Publishers', () => {
+  const mockTemplate: TemplateEntityV1alpha1 = {
+    apiVersion: 'backstage.io/v1alpha1',
+    kind: 'Template',
+    metadata: {
+      annotations: {
+        [LOCATION_ANNOTATION]:
+          'github:https://github.com/benjdlambert/backstage-graphql-template/blob/master/template.yaml',
+      },
+      name: 'graphql-starter',
+      title: 'GraphQL Service',
+      description:
+        'A GraphQL starter template for backstage to get you up and running\nthe best pracices with GraphQL\n',
+      uid: '9cf16bad-16e0-4213-b314-c4eec773c50b',
+      etag: 'ZTkxMjUxMjUtYWY3Yi00MjU2LWFkYWMtZTZjNjU5ZjJhOWM2',
+      generation: 1,
+    },
+    spec: {
+      type: 'website',
+      templater: 'cookiecutter',
+      path: './template',
+      schema: {
+        $schema: 'http://json-schema.org/draft-07/schema#',
+        required: ['storePath', 'owner'],
+        properties: {
+          owner: {
+            type: 'string',
+            title: 'Owner',
+            description: 'Who is going to own this component',
+          },
+          storePath: {
+            type: 'string',
+            title: 'Store path',
+            description: 'GitHub store path in org/repo format',
+          },
+        },
+      },
+    },
+  };
+
+  it('should throw an error when the publisher for the source location is not registered', () => {
+    const publishers = new Publishers();
+
+    expect(() => publishers.get(mockTemplate)).toThrow(
+      expect.objectContaining({
+        message: 'No publisher registered for type: "github"',
+      }),
+    );
+  });
+
+  it('should return the correct preparer when the source matches', () => {
+    const publishers = new Publishers();
+    const publisher = new GithubPublisher({
+      client: new Octokit(),
+      token: 'fake',
+      repoVisibility: 'public',
+    });
+    publishers.register('github', publisher);
+
+    expect(publishers.get(mockTemplate)).toBe(publisher);
+  });
+
+  it('should throw an error if the metadata tag does not exist in the entity', () => {
+    const brokenTemplate: TemplateEntityV1alpha1 = {
+      apiVersion: 'backstage.io/v1alpha1',
+      kind: 'Template',
+      metadata: {
+        annotations: {},
+        name: 'react-ssr-template',
+        title: 'React SSR Template',
+        description:
+          'Next.js application skeleton for creating isomorphic web applications.',
+        uid: '7357f4c5-aa58-4a1e-9670-18931eef771f',
+        etag: 'YWUxZWQyY2EtZDkxMC00MDM0LWI0ODAtMDgwMWY0YzdlMWIw',
+        generation: 1,
+      },
+      spec: {
+        type: 'website',
+        templater: 'cookiecutter',
+        path: '.',
+        schema: {
+          $schema: 'http://json-schema.org/draft-07/schema#',
+          required: ['storePath', 'owner'],
+          properties: {
+            owner: {
+              type: 'string',
+              title: 'Owner',
+              description: 'Who is going to own this component',
+            },
+            storePath: {
+              type: 'string',
+              title: 'Store path',
+              description: 'GitHub store path in org/repo format',
+            },
+          },
+        },
+      },
+    };
+
+    const publishers = new Publishers();
+
+    expect(() => publishers.get(brokenTemplate)).toThrow(
+      expect.objectContaining({
+        message: expect.stringContaining('No location annotation provided'),
+      }),
+    );
+  });
+});

plugins/scaffolder-backend/src/scaffolder/stages/publish/publishers.ts

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2020 Spotify AB
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { TemplateEntityV1alpha1 } from '@backstage/catalog-model';
+import { parseLocationAnnotation } from '../helpers';
+import { PublisherBase, PublisherBuilder } from './types';
+import { RemoteProtocol } from '../types';
+
+export class Publishers implements PublisherBuilder {
+  private publisherMap = new Map<RemoteProtocol, PublisherBase>();
+
+  register(protocol: RemoteProtocol, publisher: PublisherBase) {
+    this.publisherMap.set(protocol, publisher);
+  }
+
+  get(template: TemplateEntityV1alpha1): PublisherBase {
+    const { protocol } = parseLocationAnnotation(template);
+    const publisher = this.publisherMap.get(protocol);
+
+    if (!publisher) {
+      throw new Error(`No publisher registered for type: "${protocol}"`);
+    }
+
+    return publisher;
+  }
+}

plugins/scaffolder-backend/src/scaffolder/stages/publish/types.ts

@@ -16,6 +16,7 @@
 import { TemplateEntityV1alpha1 } from '@backstage/catalog-model';
 import { RequiredTemplateValues } from '../templater';
 import { JsonValue } from '@backstage/config';
+import { RemoteProtocol } from '../types';
 
 /**
  * Publisher is in charge of taking a folder created by
@@ -34,3 +35,8 @@ export type PublisherBase = {
     directory: string;
   }): Promise<{ remoteUrl: string }>;
 };
+
+export type PublisherBuilder = {
+  register(protocol: RemoteProtocol, publisher: PublisherBase): void;
+  get(template: TemplateEntityV1alpha1): PublisherBase;
+};

plugins/scaffolder-backend/src/scaffolder/stages/types.ts

@@ -0,0 +1,16 @@
+/*
+ * Copyright 2020 Spotify AB
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export type RemoteProtocol = 'file' | 'github' | 'gitlab' | 'gitlab/api';

plugins/scaffolder-backend/src/service/router.test.ts

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2020 Spotify AB
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { getVoidLogger } from '@backstage/backend-common';
+import express from 'express';
+import request from 'supertest';
+import { createRouter } from './router';
+import { Templaters, Preparers, Publishers } from '../scaffolder';
+import Docker from 'dockerode';
+
+jest.mock('dockerode');
+
+describe('createRouter', () => {
+  let app: express.Express;
+
+  beforeAll(async () => {
+    const router = await createRouter({
+      logger: getVoidLogger(),
+      preparers: new Preparers(),
+      templaters: new Templaters(),
+      publishers: new Publishers(),
+      dockerClient: new Docker(),
+    });
+    app = express().use(router);
+  });
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe('POST /v1/jobs', () => {
+    const template = {
+      apiVersion: 'backstage.io/v1alpha1',
+      kind: 'Template',
+      metadata: {
+        description: 'Create a new CRA website project',
+        name: 'create-react-app-template',
+        tags: ['experimental', 'react', 'cra'],
+        title: 'Create React App Template',
+      },
+      spec: {
+        owner: 'web@example.com',
+        path: '.',
+        schema: {
+          properties: {
+            component_id: {
+              description: 'Unique name of the component',
+              title: 'Name',
+              type: 'string',
+            },
+            description: {
+              description: 'Description of the component',
+              title: 'Description',
+              type: 'string',
+            },
+            use_typescript: {
+              default: true,
+              description: 'Include typescript',
+              title: 'Use Typescript',
+              type: 'boolean',
+            },
+          },
+          required: ['component_id', 'use_typescript'],
+        },
+        templater: 'cra',
+        type: 'website',
+      },
+    };
+
+    it('rejects template values which do not match the template schema definition', async () => {
+      const response = await request(app).post('/v1/jobs').send({
+        template,
+        values: {},
+      });
+
+      expect(response.status).toEqual(400);
+    });
+  });
+});

plugins/scaffolder-backend/src/service/router.ts

@@ -26,13 +26,14 @@ import {
   RequiredTemplateValues,
   StageContext,
   TemplaterBuilder,
-  PublisherBase,
+  PublisherBuilder,
 } from '../scaffolder';
+import { validate, ValidatorResult } from 'jsonschema';
 
 export interface RouterOptions {
   preparers: PreparerBuilder;
   templaters: TemplaterBuilder;
-  publisher: PublisherBase;
+  publishers: PublisherBuilder;
 
   logger: Logger;
   dockerClient: Docker;
@@ -47,7 +48,7 @@ export async function createRouter(
   const {
     preparers,
     templaters,
-    publisher,
+    publishers,
     logger: parentLogger,
     dockerClient,
   } = options;
@@ -84,6 +85,15 @@ export async function createRouter(
       const values: RequiredTemplateValues & Record<string, JsonValue> =
         req.body.values;
 
+      const validationResult: ValidatorResult = validate(
+        values,
+        template.spec.schema,
+      );
+      if (!validationResult.valid) {
+        res.status(400).json({ errors: validationResult.errors });
+        return;
+      }
+
       const job = jobProcessor.create({
         entity: template,
         values,
@@ -115,6 +125,7 @@ export async function createRouter(
           {
             name: 'Publish template',
             handler: async (ctx: StageContext<{ resultDir: string }>) => {
+              const publisher = publishers.get(ctx.entity);
               ctx.logger.info('Will now store the template');
               const { remoteUrl } = await publisher.publish({
                 entity: ctx.entity,

plugins/scaffolder/src/components/JobStatusModal/JobStatusModal.tsx

@@ -72,7 +72,7 @@ export const JobStatusModal = ({
       {entity && (
         <DialogActions>
           <Button
-            to={generatePath(entityRoute.path, {
+            to={generatePath(`/catalog/${entityRoute.path}`, {
               kind: entity.kind,
               optionalNamespaceAndName: [
                 entity.metadata.namespace,

plugins/scaffolder/src/components/TemplatePage/TemplatePage.tsx

@@ -67,6 +67,11 @@ const OWNER_REPO_SCHEMA = {
       title: 'Store path',
       description: 'GitHub store path in org/repo format',
     },
+    access: {
+      type: 'string' as const,
+      title: 'Access',
+      description: 'Who should have access, in org/team or user format',
+    },
   },
 };
 

plugins/techdocs-backend/package.json

@@ -25,12 +25,13 @@
     "@backstage/config": "^0.1.1-alpha.21",
     "@types/dockerode": "^2.5.34",
     "@types/express": "^4.17.6",
+    "command-exists-promise": "^2.0.2",
     "default-branch": "^1.0.8",
     "dockerode": "^3.2.1",
     "express": "^4.17.1",
     "express-promise-router": "^3.0.3",
     "fs-extra": "^9.0.1",
-    "git-url-parse": "^11.1.3",
+    "git-url-parse": "^11.2.0",
     "knex": "^0.21.1",
     "node-fetch": "^2.6.0",
     "nodegit": "^0.27.0",

plugins/techdocs-backend/src/techdocs/stages/generate/helpers.test.ts

@@ -51,6 +51,10 @@ describe('helpers', () => {
       jest
         .spyOn(mockDocker, 'run')
         .mockResolvedValue([{ Error: null, StatusCode: 0 }]);
+
+      jest
+        .spyOn(mockDocker, 'ping')
+        .mockResolvedValue(Buffer.from('OK', 'utf-8'));
     });
 
     const imageName = 'spotify/techdocs';
@@ -99,5 +103,39 @@ describe('helpers', () => {
         },
       );
     });
+
+    it('should ping docker to test availability', async () => {
+      await runDockerContainer({
+        imageName,
+        args,
+        docsDir,
+        resultDir,
+        dockerClient: mockDocker,
+      });
+
+      expect(mockDocker.ping).toHaveBeenCalled();
+    });
+
+    describe('where docker is unavailable', () => {
+      const dockerError = 'a docker error';
+
+      beforeEach(() => {
+        jest.spyOn(mockDocker, 'ping').mockImplementationOnce(() => {
+          throw new Error(dockerError);
+        });
+      });
+
+      it('should throw with a descriptive error message including the docker error message', async () => {
+        await expect(
+          runDockerContainer({
+            imageName,
+            args,
+            docsDir,
+            resultDir,
+            dockerClient: mockDocker,
+          }),
+        ).rejects.toThrow(new RegExp(`.+: ${dockerError}`));
+      });
+    });
   });
 });

plugins/techdocs-backend/src/techdocs/stages/generate/helpers.ts

@@ -18,6 +18,7 @@ import { Entity } from '@backstage/catalog-model';
 import { Writable, PassThrough } from 'stream';
 import Docker from 'dockerode';
 import { SupportedGeneratorKey } from './types';
+import { spawn } from 'child_process';
 
 // TODO: Implement proper support for more generators.
 export function getGeneratorKey(entity: Entity): SupportedGeneratorKey {
@@ -38,6 +39,13 @@ type RunDockerContainerOptions = {
   createOptions?: Docker.ContainerCreateOptions;
 };
 
+export type RunCommandOptions = {
+  command: string;
+  args: string[];
+  options: object;
+  logStream?: Writable;
+};
+
 export async function runDockerContainer({
   imageName,
   args,
@@ -47,6 +55,14 @@ export async function runDockerContainer({
   dockerClient,
   createOptions,
 }: RunDockerContainerOptions) {
+  try {
+    await dockerClient.ping();
+  } catch (e) {
+    throw new Error(
+      `This operation requires Docker. Docker does not appear to be available. Docker.ping() failed with: ${e.message}`,
+    );
+  }
+
   await new Promise((resolve, reject) => {
     dockerClient.pull(imageName, {}, (err, stream) => {
       if (err) return reject(err);
@@ -88,3 +104,41 @@ export async function runDockerContainer({
 
   return { error, statusCode };
 }
+
+/**
+ *
+ * @param options the options object
+ * @param options.command the command to run
+ * @param options.args the arguments to pass the command
+ * @param options.options options used in spawn
+ * @param options.logStream the log streamer to capture log messages
+ */
+export const runCommand = async ({
+  command,
+  args,
+  options,
+  logStream = new PassThrough(),
+}: RunCommandOptions) => {
+  await new Promise((resolve, reject) => {
+    const process = spawn(command, args, options);
+
+    process.stdout.on('data', stream => {
+      logStream.write(stream);
+    });
+
+    process.stderr.on('data', stream => {
+      logStream.write(stream);
+    });
+
+    process.on('error', error => {
+      return reject(error);
+    });
+
+    process.on('close', code => {
+      if (code !== 0) {
+        return reject(`Command ${command} failed, exit code: ${code}`);
+      }
+      return resolve();
+    });
+  });
+};

plugins/techdocs-backend/src/techdocs/stages/generate/techdocs.ts

@@ -24,7 +24,9 @@ import {
   GeneratorRunOptions,
   GeneratorRunResult,
 } from './types';
-import { runDockerContainer } from './helpers';
+import { runDockerContainer, runCommand } from './helpers';
+
+const commandExists = require('command-exists-promise');
 
 export class TechdocsGenerator implements GeneratorBase {
   private readonly logger: Logger;
@@ -46,17 +48,29 @@ export class TechdocsGenerator implements GeneratorBase {
     );
 
     try {
-      await runDockerContainer({
-        imageName: 'spotify/techdocs',
-        args: ['build', '-d', '/result'],
-        logStream,
-        docsDir: directory,
-        resultDir,
-        dockerClient,
-      });
-      this.logger.info(
-        `[TechDocs]: Successfully generated docs from ${directory} into ${resultDir}`,
-      );
+      const mkdocsInstalled = await commandExists('mkdocs');
+      if (mkdocsInstalled) {
+        await runCommand({
+          command: 'mkdocs',
+          args: ['build', '-d', resultDir, '-v'],
+          options: {
+            cwd: directory,
+          },
+          logStream,
+        });
+      } else {
+        await runDockerContainer({
+          imageName: 'spotify/techdocs',
+          args: ['build', '-d', '/result'],
+          logStream,
+          docsDir: directory,
+          resultDir,
+          dockerClient,
+        });
+        this.logger.info(
+          `[TechDocs]: Successfully generated docs from ${directory} into ${resultDir}`,
+        );
+      }
     } catch (error) {
       this.logger.debug(
         `[TechDocs]: Failed to generate docs from ${directory} into ${resultDir}`,