;
+
+// Use Grafana Dark theme by default
+export const ThemeContext = React.createContext(getTheme(GrafanaThemeType.Dark));
+
+export const withTheme = (Component: React.ComponentType
) => {
+ const WithTheme: React.FunctionComponent> = props => {
+ // @ts-ignore
+ return {theme => ;
+ };
+
+ WithTheme.displayName = `WithTheme(${Component.displayName})`;
+
+ return WithTheme;
+};
diff --git a/packages/grafana-ui/src/themes/dark.ts b/packages/grafana-ui/src/themes/dark.ts
new file mode 100644
index 00000000000..deae022f63a
--- /dev/null
+++ b/packages/grafana-ui/src/themes/dark.ts
@@ -0,0 +1,69 @@
+import tinycolor from 'tinycolor2';
+import defaultTheme from './default';
+import { GrafanaTheme, GrafanaThemeType } from '../types/theme';
+
+const basicColors = {
+ black: '#000000',
+ white: '#ffffff',
+ dark1: '#141414',
+ dark2: '#1f1f20',
+ dark3: '#262628',
+ dark4: '#333333',
+ dark5: '#444444',
+ gray1: '#555555',
+ gray2: '#8e8e8e',
+ gray3: '#b3b3b3',
+ gray4: '#d8d9da',
+ gray5: '#ececec',
+ gray6: '#f4f5f8',
+ gray7: '#fbfbfb',
+ grayBlue: '#212327',
+ blue: '#33b5e5',
+ blueDark: '#005f81',
+ blueLight: '#00a8e6', // not used in dark theme
+ green: '#299c46',
+ red: '#d44a3a',
+ yellow: '#ecbb13',
+ pink: '#ff4444',
+ purple: '#9933cc',
+ variable: '#32d1df',
+ orange: '#eb7b18',
+};
+
+const darkTheme: GrafanaTheme = {
+ ...defaultTheme,
+ type: GrafanaThemeType.Dark,
+ name: 'Grafana Dark',
+ colors: {
+ ...basicColors,
+ inputBlack: '#09090b',
+ queryRed: '#e24d42',
+ queryGreen: '#74e680',
+ queryPurple: '#fe85fc',
+ queryKeyword: '#66d9ef',
+ queryOrange: 'eb7b18',
+ online: '#10a345',
+ warn: '#f79520',
+ critical: '#ed2e18',
+ bodyBg: '#171819',
+ pageBg: '#161719',
+ bodyColor: basicColors.gray4,
+ textColor: basicColors.gray4,
+ textColorStrong: basicColors.white,
+ textColorWeak: basicColors.gray2,
+ textColorEmphasis: basicColors.gray5,
+ textColorFaint: basicColors.dark5,
+ linkColor: new tinycolor(basicColors.white).darken(11).toString(),
+ linkColorDisabled: new tinycolor(basicColors.white).darken(11).toString(),
+ linkColorHover: basicColors.white,
+ linkColorExternal: basicColors.blue,
+ headingColor: new tinycolor(basicColors.white).darken(11).toString(),
+ },
+ background: {
+ dropdown: basicColors.dark3,
+ scrollbar: '#aeb5df',
+ scrollbar2: '#3a3a3a',
+ },
+};
+
+export default darkTheme;
diff --git a/packages/grafana-ui/src/themes/default.ts b/packages/grafana-ui/src/themes/default.ts
new file mode 100644
index 00000000000..bf318f526e7
--- /dev/null
+++ b/packages/grafana-ui/src/themes/default.ts
@@ -0,0 +1,62 @@
+
+
+const theme = {
+ name: 'Grafana Default',
+ typography: {
+ fontFamily: {
+ sansSerif: "'Roboto', Helvetica, Arial, sans-serif;",
+ serif: "Georgia, 'Times New Roman', Times, serif;",
+ monospace: "Menlo, Monaco, Consolas, 'Courier New', monospace;"
+ },
+ size: {
+ base: '13px',
+ xs: '10px',
+ s: '12px',
+ m: '14px',
+ l: '18px',
+ },
+ heading: {
+ h1: '2rem',
+ h2: '1.75rem',
+ h3: '1.5rem',
+ h4: '1.3rem',
+ h5: '1.2rem',
+ h6: '1rem',
+ },
+ weight: {
+ light: 300,
+ normal: 400,
+ semibold: 500,
+ },
+ lineHeight: {
+ xs: 1,
+ s: 1.1,
+ m: 4/3,
+ l: 1.5
+ }
+ },
+ brakpoints: {
+ xs: '0',
+ s: '544px',
+ m: '768px',
+ l: '992px',
+ xl: '1200px'
+ },
+ spacing: {
+ xs: '0',
+ s: '0.2rem',
+ m: '1rem',
+ l: '1.5rem',
+ xl: '3rem',
+ gutter: '30px',
+ },
+ border: {
+ radius: {
+ xs: '2px',
+ s: '3px',
+ m: '5px',
+ }
+ }
+};
+
+export default theme;
diff --git a/packages/grafana-ui/src/themes/index.ts b/packages/grafana-ui/src/themes/index.ts
new file mode 100644
index 00000000000..c0d9a4f2d32
--- /dev/null
+++ b/packages/grafana-ui/src/themes/index.ts
@@ -0,0 +1,14 @@
+import darkTheme from './dark';
+import lightTheme from './light';
+import { GrafanaTheme } from '../types/theme';
+
+let themeMock: ((name?: string) => GrafanaTheme) | null;
+
+export let getTheme = (name?: string) => (themeMock && themeMock(name)) || (name === 'light' ? lightTheme : darkTheme);
+
+export const mockTheme = (mock: (name: string) => GrafanaTheme) => {
+ themeMock = mock;
+ return () => {
+ themeMock = null;
+ };
+};
diff --git a/packages/grafana-ui/src/themes/light.ts b/packages/grafana-ui/src/themes/light.ts
new file mode 100644
index 00000000000..fd1f1d05b95
--- /dev/null
+++ b/packages/grafana-ui/src/themes/light.ts
@@ -0,0 +1,70 @@
+import tinycolor from 'tinycolor2';
+import defaultTheme from './default';
+import { GrafanaTheme, GrafanaThemeType } from '../types/theme';
+
+const basicColors = {
+ black: '#000000',
+ white: '#ffffff',
+ dark1: '#13161d',
+ dark2: '#1e2028',
+ dark3: '#303133',
+ dark4: '#35373f',
+ dark5: '#41444b',
+ gray1: '#52545c',
+ gray2: '#767980',
+ gray3: '#acb6bf',
+ gray4: '#c7d0d9',
+ gray5: '#dde4ed',
+ gray6: '#e9edf2',
+ gray7: '#f7f8fa',
+ grayBlue: '#212327', // not used in light theme
+ blue: '#0083b3',
+ blueDark: '#005f81',
+ blueLight: '#00a8e6',
+ green: '#3aa655',
+ red: '#d44939',
+ yellow: '#ff851b',
+ pink: '#e671b8',
+ purple: '#9954bb',
+ variable: '#0083b3',
+ orange: '#ff7941',
+};
+
+const lightTheme: GrafanaTheme = {
+ ...defaultTheme,
+ type: GrafanaThemeType.Light,
+ name: 'Grafana Light',
+ colors: {
+ ...basicColors,
+ variable: basicColors.blue,
+ inputBlack: '#09090b',
+ queryRed: basicColors.red,
+ queryGreen: basicColors.green,
+ queryPurple: basicColors.purple,
+ queryKeyword: basicColors.blue,
+ queryOrange: basicColors.orange,
+ online: '#01a64f',
+ warn: '#f79520',
+ critical: '#ec2128',
+ bodyBg: basicColors.gray7,
+ pageBg: basicColors.gray7,
+ bodyColor: basicColors.gray1,
+ textColor: basicColors.gray1,
+ textColorStrong: basicColors.dark2,
+ textColorWeak: basicColors.gray2,
+ textColorEmphasis: basicColors.gray5,
+ textColorFaint: basicColors.dark4,
+ linkColor: basicColors.gray1,
+ linkColorDisabled: new tinycolor(basicColors.gray1).lighten(30).toString(),
+ linkColorHover: new tinycolor(basicColors.gray1).darken(20).toString(),
+ linkColorExternal: basicColors.blueLight,
+ headingColor: basicColors.gray1,
+ },
+ background: {
+ dropdown: basicColors.white,
+ scrollbar: basicColors.gray5,
+ scrollbar2: basicColors.gray5,
+ },
+};
+
+export default lightTheme;
diff --git a/packages/grafana-ui/src/themes/selectThemeVariant.test.ts b/packages/grafana-ui/src/themes/selectThemeVariant.test.ts
new file mode 100644
index 00000000000..66cb02a2372
--- /dev/null
+++ b/packages/grafana-ui/src/themes/selectThemeVariant.test.ts
@@ -0,0 +1,52 @@
+import { GrafanaThemeType } from '../types/theme';
+import { selectThemeVariant } from './selectThemeVariant';
+import { mockTheme } from './index';
+
+const lightThemeMock = {
+ color: {
+ red: '#ff0000',
+ green: '#00ff00',
+ },
+};
+
+const darkThemeMock = {
+ color: {
+ red: '#ff0000',
+ green: '#00ff00',
+ },
+};
+
+describe('Theme variable variant selector', () => {
+ // @ts-ignore
+ const restoreTheme = mockTheme(name => (name === GrafanaThemeType.Light ? lightThemeMock : darkThemeMock));
+
+ afterAll(() => {
+ restoreTheme();
+ });
+ it('return correct variable value for given theme', () => {
+ const theme = lightThemeMock;
+
+ const selectedValue = selectThemeVariant(
+ {
+ dark: theme.color.red,
+ light: theme.color.green,
+ },
+ GrafanaThemeType.Light
+ );
+
+ expect(selectedValue).toBe(lightThemeMock.color.green);
+ });
+
+ it('return dark theme variant if no theme given', () => {
+ const theme = lightThemeMock;
+
+ const selectedValue = selectThemeVariant(
+ {
+ dark: theme.color.red,
+ light: theme.color.green,
+ }
+ );
+
+ expect(selectedValue).toBe(lightThemeMock.color.red);
+ });
+});
diff --git a/packages/grafana-ui/src/themes/selectThemeVariant.ts b/packages/grafana-ui/src/themes/selectThemeVariant.ts
new file mode 100644
index 00000000000..e7e8e780222
--- /dev/null
+++ b/packages/grafana-ui/src/themes/selectThemeVariant.ts
@@ -0,0 +1,9 @@
+import { GrafanaThemeType } from '../types/theme';
+
+type VariantDescriptor = {
+ [key in GrafanaThemeType]: string | number;
+};
+
+export const selectThemeVariant = (variants: VariantDescriptor, currentTheme?: GrafanaThemeType) => {
+ return variants[currentTheme || GrafanaThemeType.Dark];
+};
diff --git a/packages/grafana-ui/src/types/index.ts b/packages/grafana-ui/src/types/index.ts
index e23b5e63af8..81bdf741f30 100644
--- a/packages/grafana-ui/src/types/index.ts
+++ b/packages/grafana-ui/src/types/index.ts
@@ -1,14 +1,7 @@
+
export * from './data';
export * from './time';
export * from './panel';
export * from './plugin';
export * from './datasource';
-
-export enum GrafanaTheme {
- Light = 'light',
- Dark = 'dark',
-}
-
-export interface Themeable {
- theme?: GrafanaTheme;
-}
+export * from './theme';
diff --git a/packages/grafana-ui/src/types/theme.ts b/packages/grafana-ui/src/types/theme.ts
new file mode 100644
index 00000000000..8a79658b423
--- /dev/null
+++ b/packages/grafana-ui/src/types/theme.ts
@@ -0,0 +1,129 @@
+export enum GrafanaThemeType {
+ Light = 'light',
+ Dark = 'dark',
+}
+
+export interface GrafanaTheme {
+ type: GrafanaThemeType;
+ name: string;
+ // TODO: not sure if should be a part of theme
+ brakpoints: {
+ xs: string;
+ s: string;
+ m: string;
+ l: string;
+ xl: string;
+ };
+ typography: {
+ fontFamily: {
+ sansSerif: string;
+ serif: string;
+ monospace: string;
+ };
+ size: {
+ base: string;
+ xs: string;
+ s: string;
+ m: string;
+ l: string;
+ };
+ weight: {
+ light: number;
+ normal: number;
+ semibold: number;
+ };
+ lineHeight: {
+ xs: number; //1
+ s: number; //1.1
+ m: number; // 4/3
+ l: number; // 1.5
+ };
+ // TODO: Refactor to use size instead of custom defs
+ heading: {
+ h1: string;
+ h2: string;
+ h3: string;
+ h4: string;
+ h5: string;
+ h6: string;
+ };
+ };
+ spacing: {
+ xs: string;
+ s: string;
+ m: string;
+ l: string;
+ gutter: string;
+ };
+ border: {
+ radius: {
+ xs: string;
+ s: string;
+ m: string;
+ };
+ };
+ background: {
+ dropdown: string;
+ scrollbar: string;
+ scrollbar2: string;
+ };
+ colors: {
+ black: string;
+ white: string;
+ dark1: string;
+ dark2: string;
+ dark3: string;
+ dark4: string;
+ dark5: string;
+ gray1: string;
+ gray2: string;
+ gray3: string;
+ gray4: string;
+ gray5: string;
+ gray6: string;
+ gray7: string;
+ grayBlue: string;
+ inputBlack: string;
+
+ // Accent colors
+ blue: string;
+ blueLight: string;
+ blueDark: string;
+ green: string;
+ red: string;
+ yellow: string;
+ pink: string;
+ purple: string;
+ variable: string;
+ orange: string;
+ queryRed: string;
+ queryGreen: string;
+ queryPurple: string;
+ queryKeyword: string;
+ queryOrange: string;
+
+ // Status colors
+ online: string;
+ warn: string;
+ critical: string;
+
+ // TODO: move to background section
+ bodyBg: string;
+ pageBg: string;
+ bodyColor: string;
+ textColor: string;
+ textColorStrong: string;
+ textColorWeak: string;
+ textColorFaint: string;
+ textColorEmphasis: string;
+ linkColor: string;
+ linkColorDisabled: string;
+ linkColorHover: string;
+ linkColorExternal: string;
+ headingColor: string;
+ };
+}
+
+export interface Themeable {
+ theme: GrafanaTheme;
+}
diff --git a/packages/grafana-ui/src/utils/namedColorsPalette.test.ts b/packages/grafana-ui/src/utils/namedColorsPalette.test.ts
index c6a1aaf0dd0..19c7d9c84ad 100644
--- a/packages/grafana-ui/src/utils/namedColorsPalette.test.ts
+++ b/packages/grafana-ui/src/utils/namedColorsPalette.test.ts
@@ -5,20 +5,20 @@ import {
getColorFromHexRgbOrName,
getColorDefinitionByName,
} from './namedColorsPalette';
-import { GrafanaTheme } from '../types/index';
+import { GrafanaThemeType } from '../types/index';
describe('colors', () => {
const SemiDarkBlue = getColorDefinitionByName('semi-dark-blue');
describe('getColorDefinition', () => {
it('returns undefined for unknown hex', () => {
- expect(getColorDefinition('#ff0000', GrafanaTheme.Light)).toBeUndefined();
- expect(getColorDefinition('#ff0000', GrafanaTheme.Dark)).toBeUndefined();
+ expect(getColorDefinition('#ff0000', GrafanaThemeType.Light)).toBeUndefined();
+ expect(getColorDefinition('#ff0000', GrafanaThemeType.Dark)).toBeUndefined();
});
it('returns definition for known hex', () => {
- expect(getColorDefinition(SemiDarkBlue.variants.light, GrafanaTheme.Light)).toEqual(SemiDarkBlue);
- expect(getColorDefinition(SemiDarkBlue.variants.dark, GrafanaTheme.Dark)).toEqual(SemiDarkBlue);
+ expect(getColorDefinition(SemiDarkBlue.variants.light, GrafanaThemeType.Light)).toEqual(SemiDarkBlue);
+ expect(getColorDefinition(SemiDarkBlue.variants.dark, GrafanaThemeType.Dark)).toEqual(SemiDarkBlue);
});
});
@@ -28,8 +28,8 @@ describe('colors', () => {
});
it('returns name for known hex', () => {
- expect(getColorName(SemiDarkBlue.variants.light, GrafanaTheme.Light)).toEqual(SemiDarkBlue.name);
- expect(getColorName(SemiDarkBlue.variants.dark, GrafanaTheme.Dark)).toEqual(SemiDarkBlue.name);
+ expect(getColorName(SemiDarkBlue.variants.light, GrafanaThemeType.Light)).toEqual(SemiDarkBlue.name);
+ expect(getColorName(SemiDarkBlue.variants.dark, GrafanaThemeType.Dark)).toEqual(SemiDarkBlue.name);
});
});
@@ -44,8 +44,8 @@ describe('colors', () => {
});
describe('getColorFromHexRgbOrName', () => {
- it('returns undefined for unknown color', () => {
- expect(() => getColorFromHexRgbOrName('aruba-sunshine')).toThrow();
+ it('returns black for unknown color', () => {
+ expect(getColorFromHexRgbOrName('aruba-sunshine')).toBe("#000000");
});
it('returns dark hex variant for known color if theme not specified', () => {
@@ -53,14 +53,20 @@ describe('colors', () => {
});
it("returns correct variant's hex for known color if theme specified", () => {
- expect(getColorFromHexRgbOrName(SemiDarkBlue.name, GrafanaTheme.Light)).toBe(SemiDarkBlue.variants.light);
+ expect(getColorFromHexRgbOrName(SemiDarkBlue.name, GrafanaThemeType.Light)).toBe(SemiDarkBlue.variants.light);
});
it('returns color if specified as hex or rgb/a', () => {
expect(getColorFromHexRgbOrName('ff0000')).toBe('ff0000');
expect(getColorFromHexRgbOrName('#ff0000')).toBe('#ff0000');
+ expect(getColorFromHexRgbOrName('#FF0000')).toBe('#FF0000');
+ expect(getColorFromHexRgbOrName('#CCC')).toBe('#CCC');
expect(getColorFromHexRgbOrName('rgb(0,0,0)')).toBe('rgb(0,0,0)');
expect(getColorFromHexRgbOrName('rgba(0,0,0,1)')).toBe('rgba(0,0,0,1)');
});
+
+ it('returns hex for named color that is not a part of named colors palette', () => {
+ expect(getColorFromHexRgbOrName('lime')).toBe('#00ff00');
+ });
});
});
diff --git a/packages/grafana-ui/src/utils/namedColorsPalette.ts b/packages/grafana-ui/src/utils/namedColorsPalette.ts
index 5312b27ad26..88ae510a6d8 100644
--- a/packages/grafana-ui/src/utils/namedColorsPalette.ts
+++ b/packages/grafana-ui/src/utils/namedColorsPalette.ts
@@ -1,5 +1,6 @@
import { flatten } from 'lodash';
-import { GrafanaTheme } from '../types';
+import { GrafanaThemeType } from '../types';
+import tinycolor from 'tinycolor2';
type Hue = 'green' | 'yellow' | 'red' | 'blue' | 'orange' | 'purple';
@@ -68,16 +69,16 @@ export const getColorDefinitionByName = (name: Color): ColorDefinition => {
return flatten(Array.from(getNamedColorPalette().values())).filter(definition => definition.name === name)[0];
};
-export const getColorDefinition = (hex: string, theme: GrafanaTheme): ColorDefinition | undefined => {
+export const getColorDefinition = (hex: string, theme: GrafanaThemeType): ColorDefinition | undefined => {
return flatten(Array.from(getNamedColorPalette().values())).filter(definition => definition.variants[theme] === hex)[0];
};
const isHex = (color: string) => {
- const hexRegex = /^((0x){0,1}|#{0,1})([0-9A-F]{8}|[0-9A-F]{6})$/gi;
+ const hexRegex = /^((0x){0,1}|#{0,1})([0-9A-F]{8}|[0-9A-F]{6}|[0-9A-F]{3})$/gi;
return hexRegex.test(color);
};
-export const getColorName = (color?: string, theme?: GrafanaTheme): Color | undefined => {
+export const getColorName = (color?: string, theme?: GrafanaThemeType): Color | undefined => {
if (!color) {
return undefined;
}
@@ -86,7 +87,7 @@ export const getColorName = (color?: string, theme?: GrafanaTheme): Color | unde
return undefined;
}
if (isHex(color)) {
- const definition = getColorDefinition(color, theme || GrafanaTheme.Dark);
+ const definition = getColorDefinition(color, theme || GrafanaThemeType.Dark);
return definition ? definition.name : undefined;
}
@@ -98,7 +99,7 @@ export const getColorByName = (colorName: string) => {
return definition.length > 0 ? definition[0] : undefined;
};
-export const getColorFromHexRgbOrName = (color: string, theme?: GrafanaTheme): string => {
+export const getColorFromHexRgbOrName = (color: string, theme?: GrafanaThemeType): string => {
if (color.indexOf('rgb') > -1 || isHex(color)) {
return color;
}
@@ -106,20 +107,20 @@ export const getColorFromHexRgbOrName = (color: string, theme?: GrafanaTheme): s
const colorDefinition = getColorByName(color);
if (!colorDefinition) {
- throw new Error('Unknown color');
+ return new tinycolor(color).toHexString();
}
return theme ? colorDefinition.variants[theme] : colorDefinition.variants.dark;
};
-export const getColorForTheme = (color: ColorDefinition, theme?: GrafanaTheme) => {
+export const getColorForTheme = (color: ColorDefinition, theme?: GrafanaThemeType) => {
return theme ? color.variants[theme] : color.variants.dark;
};
const buildNamedColorsPalette = () => {
const palette = new Map();
- const BasicGreen = buildColorDefinition('green', 'green', ['#56A64B', '#73BF69'], true);
+ const BasicGreen = buildColorDefinition('green', 'green', ['#56A64B', '#73BF69'], true);
const DarkGreen = buildColorDefinition('green', 'dark-green', ['#19730E', '#37872D']);
const SemiDarkGreen = buildColorDefinition('green', 'semi-dark-green', ['#37872D', '#56A64B']);
const LightGreen = buildColorDefinition('green', 'light-green', ['#73BF69', '#96D98D']);
diff --git a/packages/grafana-ui/src/utils/storybook/themeKnob.ts b/packages/grafana-ui/src/utils/storybook/themeKnob.ts
deleted file mode 100644
index a3733462bea..00000000000
--- a/packages/grafana-ui/src/utils/storybook/themeKnob.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import { select } from '@storybook/addon-knobs';
-import { GrafanaTheme } from '../../types';
-
-export const getThemeKnob = (defaultTheme: GrafanaTheme = GrafanaTheme.Dark) => {
- return select(
- 'Theme',
- {
- Default: defaultTheme,
- Light: GrafanaTheme.Light,
- Dark: GrafanaTheme.Dark,
- },
- defaultTheme
- );
-};
diff --git a/packages/grafana-ui/src/utils/storybook/withTheme.tsx b/packages/grafana-ui/src/utils/storybook/withTheme.tsx
new file mode 100644
index 00000000000..5417af1de05
--- /dev/null
+++ b/packages/grafana-ui/src/utils/storybook/withTheme.tsx
@@ -0,0 +1,41 @@
+import React from 'react';
+import { RenderFunction } from '@storybook/react';
+import { ThemeContext } from '../../themes/ThemeContext';
+import { select } from '@storybook/addon-knobs';
+import { getTheme } from '../../themes';
+import { GrafanaThemeType } from '../../types';
+
+const ThemableStory: React.FunctionComponent<{}> = ({ children }) => {
+ const themeKnob = select(
+ 'Theme',
+ {
+ Light: GrafanaThemeType.Light,
+ Dark: GrafanaThemeType.Dark,
+ },
+ GrafanaThemeType.Dark
+ );
+
+ return (
+
+ {children}
+
+
+ );
+};
+
+// Temporary solution. When we update to Storybook V5 we will be able to pass data from decorator to story
+// https://github.com/storybooks/storybook/issues/340#issuecomment-456013702
+export const renderComponentWithTheme = (component: React.ComponentType, props: any) => {
+ return (
+
+ {theme => {
+ return React.createElement(component, {
+ ...props,
+ theme,
+ });
+ }}
+
+ );
+};
+
+export const withTheme = (story: RenderFunction) => {story()} ;
diff --git a/packaging/deb/control/postinst b/packaging/deb/control/postinst
index 351c966a8e6..957f8aef307 100755
--- a/packaging/deb/control/postinst
+++ b/packaging/deb/control/postinst
@@ -31,11 +31,16 @@ case "$1" in
cp /usr/share/grafana/conf/ldap.toml /etc/grafana/ldap.toml
fi
- if [ ! -f $PROVISIONING_CFG_DIR ]; then
+ if [ ! -d $PROVISIONING_CFG_DIR ]; then
mkdir -p $PROVISIONING_CFG_DIR/dashboards $PROVISIONING_CFG_DIR/datasources
cp /usr/share/grafana/conf/provisioning/dashboards/sample.yaml $PROVISIONING_CFG_DIR/dashboards/sample.yaml
cp /usr/share/grafana/conf/provisioning/datasources/sample.yaml $PROVISIONING_CFG_DIR/datasources/sample.yaml
- fi
+ fi
+
+ if [ ! -d $PROVISIONING_CFG_DIR/notifiers ]; then
+ mkdir -p $PROVISIONING_CFG_DIR/notifiers
+ cp /usr/share/grafana/conf/provisioning/notifiers/sample.yaml $PROVISIONING_CFG_DIR/notifiers/sample.yaml
+ fi
# configuration files should not be modifiable by grafana user, as this can be a security issue
chown -Rh root:$GRAFANA_GROUP /etc/grafana/*
diff --git a/packaging/docker/Dockerfile b/packaging/docker/Dockerfile
index d4f2f2aa7a3..d783cb14377 100644
--- a/packaging/docker/Dockerfile
+++ b/packaging/docker/Dockerfile
@@ -39,6 +39,7 @@ RUN mkdir -p "$GF_PATHS_HOME/.aws" && \
useradd -r -u $GF_UID -g grafana grafana && \
mkdir -p "$GF_PATHS_PROVISIONING/datasources" \
"$GF_PATHS_PROVISIONING/dashboards" \
+ "$GF_PATHS_PROVISIONING/notifiers" \
"$GF_PATHS_LOGS" \
"$GF_PATHS_PLUGINS" \
"$GF_PATHS_DATA" && \
diff --git a/packaging/rpm/control/postinst b/packaging/rpm/control/postinst
index e75850f258e..cd679838487 100755
--- a/packaging/rpm/control/postinst
+++ b/packaging/rpm/control/postinst
@@ -45,11 +45,16 @@ if [ $1 -eq 1 ] ; then
cp /usr/share/grafana/conf/ldap.toml /etc/grafana/ldap.toml
fi
- if [ ! -f $PROVISIONING_CFG_DIR ]; then
+ if [ ! -d $PROVISIONING_CFG_DIR ]; then
mkdir -p $PROVISIONING_CFG_DIR/dashboards $PROVISIONING_CFG_DIR/datasources
cp /usr/share/grafana/conf/provisioning/dashboards/sample.yaml $PROVISIONING_CFG_DIR/dashboards/sample.yaml
cp /usr/share/grafana/conf/provisioning/datasources/sample.yaml $PROVISIONING_CFG_DIR/datasources/sample.yaml
- fi
+ fi
+
+ if [ ! -d $PROVISIONING_CFG_DIR/notifiers ]; then
+ mkdir -p $PROVISIONING_CFG_DIR/notifiers
+ cp /usr/share/grafana/conf/provisioning/notifiers/sample.yaml $PROVISIONING_CFG_DIR/notifiers/sample.yaml
+ fi
# Set user permissions on /var/log/grafana, /var/lib/grafana
mkdir -p /var/log/grafana /var/lib/grafana
diff --git a/pkg/api/annotations.go b/pkg/api/annotations.go
index 242b5531f51..de9d2517caa 100644
--- a/pkg/api/annotations.go
+++ b/pkg/api/annotations.go
@@ -210,6 +210,65 @@ func UpdateAnnotation(c *m.ReqContext, cmd dtos.UpdateAnnotationsCmd) Response {
return Success("Annotation updated")
}
+func PatchAnnotation(c *m.ReqContext, cmd dtos.PatchAnnotationsCmd) Response {
+ annotationID := c.ParamsInt64(":annotationId")
+
+ repo := annotations.GetRepository()
+
+ if resp := canSave(c, repo, annotationID); resp != nil {
+ return resp
+ }
+
+ items, err := repo.Find(&annotations.ItemQuery{AnnotationId: annotationID, OrgId: c.OrgId})
+
+ if err != nil || len(items) == 0 {
+ return Error(404, "Could not find annotation to update", err)
+ }
+
+ existing := annotations.Item{
+ OrgId: c.OrgId,
+ UserId: c.UserId,
+ Id: annotationID,
+ Epoch: items[0].Time,
+ Text: items[0].Text,
+ Tags: items[0].Tags,
+ RegionId: items[0].RegionId,
+ }
+
+ if cmd.Tags != nil {
+ existing.Tags = cmd.Tags
+ }
+
+ if cmd.Text != "" && cmd.Text != existing.Text {
+ existing.Text = cmd.Text
+ }
+
+ if cmd.Time > 0 && cmd.Time != existing.Epoch {
+ existing.Epoch = cmd.Time
+ }
+
+ if err := repo.Update(&existing); err != nil {
+ return Error(500, "Failed to update annotation", err)
+ }
+
+ // Update region end time if provided
+ if existing.RegionId != 0 && cmd.TimeEnd > 0 {
+ itemRight := existing
+ itemRight.RegionId = existing.Id
+ itemRight.Epoch = cmd.TimeEnd
+
+ // We don't know id of region right event, so set it to 0 and find then using query like
+ // ... WHERE region_id = AND id != ...
+ itemRight.Id = 0
+
+ if err := repo.Update(&itemRight); err != nil {
+ return Error(500, "Failed to update annotation for region end time", err)
+ }
+ }
+
+ return Success("Annotation patched")
+}
+
func DeleteAnnotations(c *m.ReqContext, cmd dtos.DeleteAnnotationsCmd) Response {
repo := annotations.GetRepository()
diff --git a/pkg/api/annotations_test.go b/pkg/api/annotations_test.go
index 08f3018c694..ebdd867a031 100644
--- a/pkg/api/annotations_test.go
+++ b/pkg/api/annotations_test.go
@@ -27,6 +27,12 @@ func TestAnnotationsApiEndpoint(t *testing.T) {
IsRegion: false,
}
+ patchCmd := dtos.PatchAnnotationsCmd{
+ Time: 1000,
+ Text: "annotation text",
+ Tags: []string{"tag1", "tag2"},
+ }
+
Convey("When user is an Org Viewer", func() {
role := m.ROLE_VIEWER
Convey("Should not be allowed to save an annotation", func() {
@@ -40,6 +46,11 @@ func TestAnnotationsApiEndpoint(t *testing.T) {
So(sc.resp.Code, ShouldEqual, 403)
})
+ patchAnnotationScenario("When calling PATCH on", "/api/annotations/1", "/api/annotations/:annotationId", role, patchCmd, func(sc *scenarioContext) {
+ sc.fakeReqWithParams("PATCH", sc.url, map[string]string{}).exec()
+ So(sc.resp.Code, ShouldEqual, 403)
+ })
+
loggedInUserScenarioWithRole("When calling DELETE on", "DELETE", "/api/annotations/1", "/api/annotations/:annotationId", role, func(sc *scenarioContext) {
sc.handlerFunc = DeleteAnnotationByID
sc.fakeReqWithParams("DELETE", sc.url, map[string]string{}).exec()
@@ -67,6 +78,11 @@ func TestAnnotationsApiEndpoint(t *testing.T) {
So(sc.resp.Code, ShouldEqual, 200)
})
+ patchAnnotationScenario("When calling PATCH on", "/api/annotations/1", "/api/annotations/:annotationId", role, patchCmd, func(sc *scenarioContext) {
+ sc.fakeReqWithParams("PATCH", sc.url, map[string]string{}).exec()
+ So(sc.resp.Code, ShouldEqual, 200)
+ })
+
loggedInUserScenarioWithRole("When calling DELETE on", "DELETE", "/api/annotations/1", "/api/annotations/:annotationId", role, func(sc *scenarioContext) {
sc.handlerFunc = DeleteAnnotationByID
sc.fakeReqWithParams("DELETE", sc.url, map[string]string{}).exec()
@@ -100,6 +116,13 @@ func TestAnnotationsApiEndpoint(t *testing.T) {
Id: 1,
}
+ patchCmd := dtos.PatchAnnotationsCmd{
+ Time: 8000,
+ Text: "annotation text 50",
+ Tags: []string{"foo", "bar"},
+ Id: 1,
+ }
+
deleteCmd := dtos.DeleteAnnotationsCmd{
DashboardId: 1,
PanelId: 1,
@@ -136,6 +159,11 @@ func TestAnnotationsApiEndpoint(t *testing.T) {
So(sc.resp.Code, ShouldEqual, 403)
})
+ patchAnnotationScenario("When calling PATCH on", "/api/annotations/1", "/api/annotations/:annotationId", role, patchCmd, func(sc *scenarioContext) {
+ sc.fakeReqWithParams("PATCH", sc.url, map[string]string{}).exec()
+ So(sc.resp.Code, ShouldEqual, 403)
+ })
+
loggedInUserScenarioWithRole("When calling DELETE on", "DELETE", "/api/annotations/1", "/api/annotations/:annotationId", role, func(sc *scenarioContext) {
sc.handlerFunc = DeleteAnnotationByID
sc.fakeReqWithParams("DELETE", sc.url, map[string]string{}).exec()
@@ -163,6 +191,11 @@ func TestAnnotationsApiEndpoint(t *testing.T) {
So(sc.resp.Code, ShouldEqual, 200)
})
+ patchAnnotationScenario("When calling PATCH on", "/api/annotations/1", "/api/annotations/:annotationId", role, patchCmd, func(sc *scenarioContext) {
+ sc.fakeReqWithParams("PATCH", sc.url, map[string]string{}).exec()
+ So(sc.resp.Code, ShouldEqual, 200)
+ })
+
loggedInUserScenarioWithRole("When calling DELETE on", "DELETE", "/api/annotations/1", "/api/annotations/:annotationId", role, func(sc *scenarioContext) {
sc.handlerFunc = DeleteAnnotationByID
sc.fakeReqWithParams("DELETE", sc.url, map[string]string{}).exec()
@@ -189,6 +222,12 @@ func TestAnnotationsApiEndpoint(t *testing.T) {
sc.fakeReqWithParams("PUT", sc.url, map[string]string{}).exec()
So(sc.resp.Code, ShouldEqual, 200)
})
+
+ patchAnnotationScenario("When calling PATCH on", "/api/annotations/1", "/api/annotations/:annotationId", role, patchCmd, func(sc *scenarioContext) {
+ sc.fakeReqWithParams("PATCH", sc.url, map[string]string{}).exec()
+ So(sc.resp.Code, ShouldEqual, 200)
+ })
+
deleteAnnotationsScenario("When calling POST on", "/api/annotations/mass-delete", "/api/annotations/mass-delete", role, deleteCmd, func(sc *scenarioContext) {
sc.fakeReqWithParams("POST", sc.url, map[string]string{}).exec()
So(sc.resp.Code, ShouldEqual, 200)
@@ -264,6 +303,29 @@ func putAnnotationScenario(desc string, url string, routePattern string, role m.
})
}
+func patchAnnotationScenario(desc string, url string, routePattern string, role m.RoleType, cmd dtos.PatchAnnotationsCmd, fn scenarioFunc) {
+ Convey(desc+" "+url, func() {
+ defer bus.ClearBusHandlers()
+
+ sc := setupScenarioContext(url)
+ sc.defaultHandler = Wrap(func(c *m.ReqContext) Response {
+ sc.context = c
+ sc.context.UserId = TestUserID
+ sc.context.OrgId = TestOrgID
+ sc.context.OrgRole = role
+
+ return PatchAnnotation(c, cmd)
+ })
+
+ fakeAnnoRepo = &fakeAnnotationsRepo{}
+ annotations.SetRepository(fakeAnnoRepo)
+
+ sc.m.Patch(routePattern, sc.defaultHandler)
+
+ fn(sc)
+ })
+}
+
func deleteAnnotationsScenario(desc string, url string, routePattern string, role m.RoleType, cmd dtos.DeleteAnnotationsCmd, fn scenarioFunc) {
Convey(desc+" "+url, func() {
defer bus.ClearBusHandlers()
diff --git a/pkg/api/api.go b/pkg/api/api.go
index 980706d8355..0685ef3814d 100644
--- a/pkg/api/api.go
+++ b/pkg/api/api.go
@@ -354,6 +354,7 @@ func (hs *HTTPServer) registerRoutes() {
annotationsRoute.Post("/", bind(dtos.PostAnnotationsCmd{}), Wrap(PostAnnotation))
annotationsRoute.Delete("/:annotationId", Wrap(DeleteAnnotationByID))
annotationsRoute.Put("/:annotationId", bind(dtos.UpdateAnnotationsCmd{}), Wrap(UpdateAnnotation))
+ annotationsRoute.Patch("/:annotationId", bind(dtos.PatchAnnotationsCmd{}), Wrap(PatchAnnotation))
annotationsRoute.Delete("/region/:regionId", Wrap(DeleteAnnotationRegion))
annotationsRoute.Post("/graphite", reqEditorRole, bind(dtos.PostGraphiteAnnotationsCmd{}), Wrap(PostGraphiteAnnotation))
})
diff --git a/pkg/api/common_test.go b/pkg/api/common_test.go
index fe02c94e277..3f3a50aae69 100644
--- a/pkg/api/common_test.go
+++ b/pkg/api/common_test.go
@@ -94,14 +94,13 @@ func (sc *scenarioContext) fakeReqWithParams(method, url string, queryParams map
}
type scenarioContext struct {
- m *macaron.Macaron
- context *m.ReqContext
- resp *httptest.ResponseRecorder
- handlerFunc handlerFunc
- defaultHandler macaron.Handler
- req *http.Request
- url string
- userAuthTokenService *fakeUserAuthTokenService
+ m *macaron.Macaron
+ context *m.ReqContext
+ resp *httptest.ResponseRecorder
+ handlerFunc handlerFunc
+ defaultHandler macaron.Handler
+ req *http.Request
+ url string
}
func (sc *scenarioContext) exec() {
@@ -123,30 +122,7 @@ func setupScenarioContext(url string) *scenarioContext {
Delims: macaron.Delims{Left: "[[", Right: "]]"},
}))
- sc.userAuthTokenService = newFakeUserAuthTokenService()
- sc.m.Use(middleware.GetContextHandler(sc.userAuthTokenService))
+ sc.m.Use(middleware.GetContextHandler(nil))
return sc
}
-
-type fakeUserAuthTokenService struct {
- initContextWithTokenProvider func(ctx *m.ReqContext, orgID int64) bool
-}
-
-func newFakeUserAuthTokenService() *fakeUserAuthTokenService {
- return &fakeUserAuthTokenService{
- initContextWithTokenProvider: func(ctx *m.ReqContext, orgID int64) bool {
- return false
- },
- }
-}
-
-func (s *fakeUserAuthTokenService) InitContextWithToken(ctx *m.ReqContext, orgID int64) bool {
- return s.initContextWithTokenProvider(ctx, orgID)
-}
-
-func (s *fakeUserAuthTokenService) UserAuthenticatedHook(user *m.User, c *m.ReqContext) error {
- return nil
-}
-
-func (s *fakeUserAuthTokenService) SignOutUser(c *m.ReqContext) error { return nil }
diff --git a/pkg/api/dtos/annotations.go b/pkg/api/dtos/annotations.go
index c917b0d9feb..bdee8599fea 100644
--- a/pkg/api/dtos/annotations.go
+++ b/pkg/api/dtos/annotations.go
@@ -22,6 +22,14 @@ type UpdateAnnotationsCmd struct {
TimeEnd int64 `json:"timeEnd"`
}
+type PatchAnnotationsCmd struct {
+ Id int64 `json:"id"`
+ Time int64 `json:"time"`
+ Text string `json:"text"`
+ Tags []string `json:"tags"`
+ TimeEnd int64 `json:"timeEnd"`
+}
+
type DeleteAnnotationsCmd struct {
AlertId int64 `json:"alertId"`
DashboardId int64 `json:"dashboardId"`
diff --git a/pkg/api/dtos/playlist.go b/pkg/api/dtos/playlist.go
index 317ff83339a..7f43bb4df8a 100644
--- a/pkg/api/dtos/playlist.go
+++ b/pkg/api/dtos/playlist.go
@@ -5,6 +5,7 @@ type PlaylistDashboard struct {
Slug string `json:"slug"`
Title string `json:"title"`
Uri string `json:"uri"`
+ Url string `json:"url"`
Order int `json:"order"`
}
diff --git a/pkg/api/http_server.go b/pkg/api/http_server.go
index 7b7c1478a4c..cadf6896bf4 100644
--- a/pkg/api/http_server.go
+++ b/pkg/api/http_server.go
@@ -21,7 +21,6 @@ import (
"github.com/grafana/grafana/pkg/models"
"github.com/grafana/grafana/pkg/plugins"
"github.com/grafana/grafana/pkg/registry"
- "github.com/grafana/grafana/pkg/services/auth"
"github.com/grafana/grafana/pkg/services/cache"
"github.com/grafana/grafana/pkg/services/datasources"
"github.com/grafana/grafana/pkg/services/hooks"
@@ -48,14 +47,14 @@ type HTTPServer struct {
streamManager *live.StreamManager
httpSrv *http.Server
- RouteRegister routing.RouteRegister `inject:""`
- Bus bus.Bus `inject:""`
- RenderService rendering.Service `inject:""`
- Cfg *setting.Cfg `inject:""`
- HooksService *hooks.HooksService `inject:""`
- CacheService *cache.CacheService `inject:""`
- DatasourceCache datasources.CacheService `inject:""`
- AuthTokenService auth.UserAuthTokenService `inject:""`
+ RouteRegister routing.RouteRegister `inject:""`
+ Bus bus.Bus `inject:""`
+ RenderService rendering.Service `inject:""`
+ Cfg *setting.Cfg `inject:""`
+ HooksService *hooks.HooksService `inject:""`
+ CacheService *cache.CacheService `inject:""`
+ DatasourceCache datasources.CacheService `inject:""`
+ AuthTokenService models.UserTokenService `inject:""`
}
func (hs *HTTPServer) Init() error {
diff --git a/pkg/api/login.go b/pkg/api/login.go
index 49da147724e..106a48dd6a8 100644
--- a/pkg/api/login.go
+++ b/pkg/api/login.go
@@ -10,6 +10,7 @@ import (
"github.com/grafana/grafana/pkg/log"
"github.com/grafana/grafana/pkg/login"
"github.com/grafana/grafana/pkg/metrics"
+ "github.com/grafana/grafana/pkg/middleware"
m "github.com/grafana/grafana/pkg/models"
"github.com/grafana/grafana/pkg/setting"
"github.com/grafana/grafana/pkg/util"
@@ -126,17 +127,23 @@ func (hs *HTTPServer) LoginPost(c *m.ReqContext, cmd dtos.LoginCommand) Response
func (hs *HTTPServer) loginUserWithUser(user *m.User, c *m.ReqContext) {
if user == nil {
- hs.log.Error("User login with nil user")
+ hs.log.Error("user login with nil user")
}
- err := hs.AuthTokenService.UserAuthenticatedHook(user, c)
+ userToken, err := hs.AuthTokenService.CreateToken(user.Id, c.RemoteAddr(), c.Req.UserAgent())
if err != nil {
- hs.log.Error("User auth hook failed", "error", err)
+ hs.log.Error("failed to create auth token", "error", err)
}
+
+ middleware.WriteSessionCookie(c, userToken.UnhashedToken, hs.Cfg.LoginMaxLifetimeDays)
}
func (hs *HTTPServer) Logout(c *m.ReqContext) {
- hs.AuthTokenService.SignOutUser(c)
+ if err := hs.AuthTokenService.RevokeToken(c.UserToken); err != nil && err != m.ErrUserTokenNotFound {
+ hs.log.Error("failed to revoke auth token", "error", err)
+ }
+
+ middleware.WriteSessionCookie(c, "", -1)
if setting.SignoutRedirectUrl != "" {
c.Redirect(setting.SignoutRedirectUrl)
@@ -176,7 +183,8 @@ func (hs *HTTPServer) trySetEncryptedCookie(ctx *m.ReqContext, cookieName string
Value: hex.EncodeToString(encryptedError),
HttpOnly: true,
Path: setting.AppSubUrl + "/",
- Secure: hs.Cfg.SecurityHTTPSCookies,
+ Secure: hs.Cfg.CookieSecure,
+ SameSite: hs.Cfg.CookieSameSite,
})
return nil
diff --git a/pkg/api/login_oauth.go b/pkg/api/login_oauth.go
index 4160d48733e..87a8ecc876f 100644
--- a/pkg/api/login_oauth.go
+++ b/pkg/api/login_oauth.go
@@ -214,7 +214,8 @@ func (hs *HTTPServer) writeCookie(w http.ResponseWriter, name string, value stri
Value: value,
HttpOnly: true,
Path: setting.AppSubUrl + "/",
- Secure: hs.Cfg.SecurityHTTPSCookies,
+ Secure: hs.Cfg.CookieSecure,
+ SameSite: hs.Cfg.CookieSameSite,
})
}
diff --git a/pkg/api/playlist_play.go b/pkg/api/playlist_play.go
index e82c7b438b4..5ca136c32c4 100644
--- a/pkg/api/playlist_play.go
+++ b/pkg/api/playlist_play.go
@@ -26,6 +26,7 @@ func populateDashboardsByID(dashboardByIDs []int64, dashboardIDOrder map[int64]i
Slug: item.Slug,
Title: item.Title,
Uri: "db/" + item.Slug,
+ Url: m.GetDashboardUrl(item.Uid, item.Slug),
Order: dashboardIDOrder[item.Id],
})
}
diff --git a/pkg/api/pluginproxy/ds_proxy.go b/pkg/api/pluginproxy/ds_proxy.go
index a0ad96a6977..b1950998297 100644
--- a/pkg/api/pluginproxy/ds_proxy.go
+++ b/pkg/api/pluginproxy/ds_proxy.go
@@ -54,7 +54,7 @@ func NewDataSourceProxy(ds *m.DataSource, plugin *plugins.DataSourcePlugin, ctx
func newHTTPClient() httpClient {
return &http.Client{
- Timeout: time.Duration(setting.DataProxyTimeout) * time.Second,
+ Timeout: 30 * time.Second,
Transport: &http.Transport{Proxy: http.ProxyFromEnvironment},
}
}
diff --git a/pkg/cmd/grafana-server/main.go b/pkg/cmd/grafana-server/main.go
index 3bdaf0cc80e..d371d4e91da 100644
--- a/pkg/cmd/grafana-server/main.go
+++ b/pkg/cmd/grafana-server/main.go
@@ -19,6 +19,7 @@ import (
_ "github.com/grafana/grafana/pkg/services/alerting/conditions"
_ "github.com/grafana/grafana/pkg/services/alerting/notifiers"
"github.com/grafana/grafana/pkg/setting"
+ _ "github.com/grafana/grafana/pkg/tsdb/azuremonitor"
_ "github.com/grafana/grafana/pkg/tsdb/cloudwatch"
_ "github.com/grafana/grafana/pkg/tsdb/elasticsearch"
_ "github.com/grafana/grafana/pkg/tsdb/graphite"
diff --git a/pkg/cmd/grafana-server/server.go b/pkg/cmd/grafana-server/server.go
index 4781361b9b9..f663e6be895 100644
--- a/pkg/cmd/grafana-server/server.go
+++ b/pkg/cmd/grafana-server/server.go
@@ -32,6 +32,7 @@ import (
_ "github.com/grafana/grafana/pkg/metrics"
_ "github.com/grafana/grafana/pkg/plugins"
_ "github.com/grafana/grafana/pkg/services/alerting"
+ _ "github.com/grafana/grafana/pkg/services/auth"
_ "github.com/grafana/grafana/pkg/services/cleanup"
_ "github.com/grafana/grafana/pkg/services/notifications"
_ "github.com/grafana/grafana/pkg/services/provisioning"
diff --git a/pkg/infra/usagestats/service.go b/pkg/infra/usagestats/service.go
new file mode 100644
index 00000000000..c2bf0d06349
--- /dev/null
+++ b/pkg/infra/usagestats/service.go
@@ -0,0 +1,54 @@
+package usagestats
+
+import (
+ "context"
+ "time"
+
+ "github.com/grafana/grafana/pkg/bus"
+ "github.com/grafana/grafana/pkg/services/sqlstore"
+ "github.com/grafana/grafana/pkg/social"
+
+ "github.com/grafana/grafana/pkg/log"
+ "github.com/grafana/grafana/pkg/registry"
+ "github.com/grafana/grafana/pkg/setting"
+)
+
+var metricsLogger log.Logger = log.New("metrics")
+
+func init() {
+ registry.RegisterService(&UsageStatsService{})
+}
+
+type UsageStatsService struct {
+ Cfg *setting.Cfg `inject:""`
+ Bus bus.Bus `inject:""`
+ SQLStore *sqlstore.SqlStore `inject:""`
+
+ oauthProviders map[string]bool
+}
+
+func (uss *UsageStatsService) Init() error {
+
+ uss.oauthProviders = social.GetOAuthProviders(uss.Cfg)
+ return nil
+}
+
+func (uss *UsageStatsService) Run(ctx context.Context) error {
+ uss.updateTotalStats()
+
+ onceEveryDayTick := time.NewTicker(time.Hour * 24)
+ everyMinuteTicker := time.NewTicker(time.Minute)
+ defer onceEveryDayTick.Stop()
+ defer everyMinuteTicker.Stop()
+
+ for {
+ select {
+ case <-onceEveryDayTick.C:
+ uss.sendUsageStats(uss.oauthProviders)
+ case <-everyMinuteTicker.C:
+ uss.updateTotalStats()
+ case <-ctx.Done():
+ return ctx.Err()
+ }
+ }
+}
diff --git a/pkg/infra/usagestats/usage_stats.go b/pkg/infra/usagestats/usage_stats.go
new file mode 100644
index 00000000000..9d7501b7765
--- /dev/null
+++ b/pkg/infra/usagestats/usage_stats.go
@@ -0,0 +1,177 @@
+package usagestats
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "runtime"
+ "strings"
+ "time"
+
+ "github.com/grafana/grafana/pkg/metrics"
+ "github.com/grafana/grafana/pkg/models"
+ "github.com/grafana/grafana/pkg/plugins"
+ "github.com/grafana/grafana/pkg/setting"
+)
+
+var usageStatsURL = "https://stats.grafana.org/grafana-usage-report"
+
+func (uss *UsageStatsService) sendUsageStats(oauthProviders map[string]bool) {
+ if !setting.ReportingEnabled {
+ return
+ }
+
+ metricsLogger.Debug(fmt.Sprintf("Sending anonymous usage stats to %s", usageStatsURL))
+
+ version := strings.Replace(setting.BuildVersion, ".", "_", -1)
+
+ metrics := map[string]interface{}{}
+ report := map[string]interface{}{
+ "version": version,
+ "metrics": metrics,
+ "os": runtime.GOOS,
+ "arch": runtime.GOARCH,
+ "edition": getEdition(),
+ "packaging": setting.Packaging,
+ }
+
+ statsQuery := models.GetSystemStatsQuery{}
+ if err := uss.Bus.Dispatch(&statsQuery); err != nil {
+ metricsLogger.Error("Failed to get system stats", "error", err)
+ return
+ }
+
+ metrics["stats.dashboards.count"] = statsQuery.Result.Dashboards
+ metrics["stats.users.count"] = statsQuery.Result.Users
+ metrics["stats.orgs.count"] = statsQuery.Result.Orgs
+ metrics["stats.playlist.count"] = statsQuery.Result.Playlists
+ metrics["stats.plugins.apps.count"] = len(plugins.Apps)
+ metrics["stats.plugins.panels.count"] = len(plugins.Panels)
+ metrics["stats.plugins.datasources.count"] = len(plugins.DataSources)
+ metrics["stats.alerts.count"] = statsQuery.Result.Alerts
+ metrics["stats.active_users.count"] = statsQuery.Result.ActiveUsers
+ metrics["stats.datasources.count"] = statsQuery.Result.Datasources
+ metrics["stats.stars.count"] = statsQuery.Result.Stars
+ metrics["stats.folders.count"] = statsQuery.Result.Folders
+ metrics["stats.dashboard_permissions.count"] = statsQuery.Result.DashboardPermissions
+ metrics["stats.folder_permissions.count"] = statsQuery.Result.FolderPermissions
+ metrics["stats.provisioned_dashboards.count"] = statsQuery.Result.ProvisionedDashboards
+ metrics["stats.snapshots.count"] = statsQuery.Result.Snapshots
+ metrics["stats.teams.count"] = statsQuery.Result.Teams
+ metrics["stats.total_auth_token.count"] = statsQuery.Result.AuthTokens
+
+ userCount := statsQuery.Result.Users
+ avgAuthTokensPerUser := statsQuery.Result.AuthTokens
+ if userCount != 0 {
+ avgAuthTokensPerUser = avgAuthTokensPerUser / userCount
+ }
+
+ metrics["stats.avg_auth_token_per_user.count"] = avgAuthTokensPerUser
+
+ dsStats := models.GetDataSourceStatsQuery{}
+ if err := uss.Bus.Dispatch(&dsStats); err != nil {
+ metricsLogger.Error("Failed to get datasource stats", "error", err)
+ return
+ }
+
+ // send counters for each data source
+ // but ignore any custom data sources
+ // as sending that name could be sensitive information
+ dsOtherCount := 0
+ for _, dsStat := range dsStats.Result {
+ if models.IsKnownDataSourcePlugin(dsStat.Type) {
+ metrics["stats.ds."+dsStat.Type+".count"] = dsStat.Count
+ } else {
+ dsOtherCount += dsStat.Count
+ }
+ }
+ metrics["stats.ds.other.count"] = dsOtherCount
+
+ metrics["stats.packaging."+setting.Packaging+".count"] = 1
+
+ dsAccessStats := models.GetDataSourceAccessStatsQuery{}
+ if err := uss.Bus.Dispatch(&dsAccessStats); err != nil {
+ metricsLogger.Error("Failed to get datasource access stats", "error", err)
+ return
+ }
+
+ // send access counters for each data source
+ // but ignore any custom data sources
+ // as sending that name could be sensitive information
+ dsAccessOtherCount := make(map[string]int64)
+ for _, dsAccessStat := range dsAccessStats.Result {
+ if dsAccessStat.Access == "" {
+ continue
+ }
+
+ access := strings.ToLower(dsAccessStat.Access)
+
+ if models.IsKnownDataSourcePlugin(dsAccessStat.Type) {
+ metrics["stats.ds_access."+dsAccessStat.Type+"."+access+".count"] = dsAccessStat.Count
+ } else {
+ old := dsAccessOtherCount[access]
+ dsAccessOtherCount[access] = old + dsAccessStat.Count
+ }
+ }
+
+ for access, count := range dsAccessOtherCount {
+ metrics["stats.ds_access.other."+access+".count"] = count
+ }
+
+ anStats := models.GetAlertNotifierUsageStatsQuery{}
+ if err := uss.Bus.Dispatch(&anStats); err != nil {
+ metricsLogger.Error("Failed to get alert notification stats", "error", err)
+ return
+ }
+
+ for _, stats := range anStats.Result {
+ metrics["stats.alert_notifiers."+stats.Type+".count"] = stats.Count
+ }
+
+ authTypes := map[string]bool{}
+ authTypes["anonymous"] = setting.AnonymousEnabled
+ authTypes["basic_auth"] = setting.BasicAuthEnabled
+ authTypes["ldap"] = setting.LdapEnabled
+ authTypes["auth_proxy"] = setting.AuthProxyEnabled
+
+ for provider, enabled := range oauthProviders {
+ authTypes["oauth_"+provider] = enabled
+ }
+
+ for authType, enabled := range authTypes {
+ enabledValue := 0
+ if enabled {
+ enabledValue = 1
+ }
+ metrics["stats.auth_enabled."+authType+".count"] = enabledValue
+ }
+
+ out, _ := json.MarshalIndent(report, "", " ")
+ data := bytes.NewBuffer(out)
+
+ client := http.Client{Timeout: 5 * time.Second}
+ go client.Post(usageStatsURL, "application/json", data)
+}
+
+func (uss *UsageStatsService) updateTotalStats() {
+ statsQuery := models.GetSystemStatsQuery{}
+ if err := uss.Bus.Dispatch(&statsQuery); err != nil {
+ metricsLogger.Error("Failed to get system stats", "error", err)
+ return
+ }
+
+ metrics.M_StatTotal_Dashboards.Set(float64(statsQuery.Result.Dashboards))
+ metrics.M_StatTotal_Users.Set(float64(statsQuery.Result.Users))
+ metrics.M_StatActive_Users.Set(float64(statsQuery.Result.ActiveUsers))
+ metrics.M_StatTotal_Playlists.Set(float64(statsQuery.Result.Playlists))
+ metrics.M_StatTotal_Orgs.Set(float64(statsQuery.Result.Orgs))
+}
+
+func getEdition() string {
+ if setting.IsEnterprise {
+ return "enterprise"
+ } else {
+ return "oss"
+ }
+}
diff --git a/pkg/metrics/metrics_test.go b/pkg/infra/usagestats/usage_stats_test.go
similarity index 91%
rename from pkg/metrics/metrics_test.go
rename to pkg/infra/usagestats/usage_stats_test.go
index c27d6f64b8c..ea5b95d6ef0 100644
--- a/pkg/metrics/metrics_test.go
+++ b/pkg/infra/usagestats/usage_stats_test.go
@@ -1,4 +1,4 @@
-package metrics
+package usagestats
import (
"bytes"
@@ -15,14 +15,21 @@ import (
"github.com/grafana/grafana/pkg/components/simplejson"
"github.com/grafana/grafana/pkg/models"
"github.com/grafana/grafana/pkg/plugins"
+ "github.com/grafana/grafana/pkg/services/sqlstore"
"github.com/grafana/grafana/pkg/setting"
. "github.com/smartystreets/goconvey/convey"
)
func TestMetrics(t *testing.T) {
Convey("Test send usage stats", t, func() {
+ uss := &UsageStatsService{
+ Bus: bus.New(),
+ SQLStore: sqlstore.InitTestDB(t),
+ }
+
var getSystemStatsQuery *models.GetSystemStatsQuery
- bus.AddHandler("test", func(query *models.GetSystemStatsQuery) error {
+ uss.Bus.AddHandler(func(query *models.GetSystemStatsQuery) error {
+
query.Result = &models.SystemStats{
Dashboards: 1,
Datasources: 2,
@@ -38,13 +45,14 @@ func TestMetrics(t *testing.T) {
ProvisionedDashboards: 12,
Snapshots: 13,
Teams: 14,
+ AuthTokens: 15,
}
getSystemStatsQuery = query
return nil
})
var getDataSourceStatsQuery *models.GetDataSourceStatsQuery
- bus.AddHandler("test", func(query *models.GetDataSourceStatsQuery) error {
+ uss.Bus.AddHandler(func(query *models.GetDataSourceStatsQuery) error {
query.Result = []*models.DataSourceStats{
{
Type: models.DS_ES,
@@ -68,7 +76,7 @@ func TestMetrics(t *testing.T) {
})
var getDataSourceAccessStatsQuery *models.GetDataSourceAccessStatsQuery
- bus.AddHandler("test", func(query *models.GetDataSourceAccessStatsQuery) error {
+ uss.Bus.AddHandler(func(query *models.GetDataSourceAccessStatsQuery) error {
query.Result = []*models.DataSourceAccessStats{
{
Type: models.DS_ES,
@@ -116,7 +124,7 @@ func TestMetrics(t *testing.T) {
})
var getAlertNotifierUsageStatsQuery *models.GetAlertNotifierUsageStatsQuery
- bus.AddHandler("test", func(query *models.GetAlertNotifierUsageStatsQuery) error {
+ uss.Bus.AddHandler(func(query *models.GetAlertNotifierUsageStatsQuery) error {
query.Result = []*models.NotifierUsageStats{
{
Type: "slack",
@@ -155,11 +163,11 @@ func TestMetrics(t *testing.T) {
"grafana_com": true,
}
- sendUsageStats(oauthProviders)
+ uss.sendUsageStats(oauthProviders)
Convey("Given reporting not enabled and sending usage stats", func() {
setting.ReportingEnabled = false
- sendUsageStats(oauthProviders)
+ uss.sendUsageStats(oauthProviders)
Convey("Should not gather stats or call http endpoint", func() {
So(getSystemStatsQuery, ShouldBeNil)
@@ -179,7 +187,7 @@ func TestMetrics(t *testing.T) {
setting.Packaging = "deb"
wg.Add(1)
- sendUsageStats(oauthProviders)
+ uss.sendUsageStats(oauthProviders)
Convey("Should gather stats and call http endpoint", func() {
if waitTimeout(&wg, 2*time.Second) {
@@ -221,6 +229,8 @@ func TestMetrics(t *testing.T) {
So(metrics.Get("stats.provisioned_dashboards.count").MustInt(), ShouldEqual, getSystemStatsQuery.Result.ProvisionedDashboards)
So(metrics.Get("stats.snapshots.count").MustInt(), ShouldEqual, getSystemStatsQuery.Result.Snapshots)
So(metrics.Get("stats.teams.count").MustInt(), ShouldEqual, getSystemStatsQuery.Result.Teams)
+ So(metrics.Get("stats.total_auth_token.count").MustInt64(), ShouldEqual, 15)
+ So(metrics.Get("stats.avg_auth_token_per_user.count").MustInt64(), ShouldEqual, 5)
So(metrics.Get("stats.ds."+models.DS_ES+".count").MustInt(), ShouldEqual, 9)
So(metrics.Get("stats.ds."+models.DS_PROMETHEUS+".count").MustInt(), ShouldEqual, 10)
@@ -246,6 +256,7 @@ func TestMetrics(t *testing.T) {
So(metrics.Get("stats.auth_enabled.oauth_grafana_com.count").MustInt(), ShouldEqual, 1)
So(metrics.Get("stats.packaging.deb.count").MustInt(), ShouldEqual, 1)
+
})
})
diff --git a/pkg/login/ldap.go b/pkg/login/ldap.go
index 402160ef5e3..c15cb865bd3 100644
--- a/pkg/login/ldap.go
+++ b/pkg/login/ldap.go
@@ -273,23 +273,35 @@ func (a *ldapAuther) initialBind(username, userPassword string) error {
return nil
}
+func appendIfNotEmpty(slice []string, values ...string) []string {
+ for _, v := range values {
+ if v != "" {
+ slice = append(slice, v)
+ }
+ }
+ return slice
+}
+
func (a *ldapAuther) searchForUser(username string) (*LdapUserInfo, error) {
var searchResult *ldap.SearchResult
var err error
for _, searchBase := range a.server.SearchBaseDNs {
+ attributes := make([]string, 0)
+ inputs := a.server.Attr
+ attributes = appendIfNotEmpty(attributes,
+ inputs.Username,
+ inputs.Surname,
+ inputs.Email,
+ inputs.Name,
+ inputs.MemberOf)
+
searchReq := ldap.SearchRequest{
BaseDN: searchBase,
Scope: ldap.ScopeWholeSubtree,
DerefAliases: ldap.NeverDerefAliases,
- Attributes: []string{
- a.server.Attr.Username,
- a.server.Attr.Surname,
- a.server.Attr.Email,
- a.server.Attr.Name,
- a.server.Attr.MemberOf,
- },
- Filter: strings.Replace(a.server.SearchFilter, "%s", ldap.EscapeFilter(username), -1),
+ Attributes: attributes,
+ Filter: strings.Replace(a.server.SearchFilter, "%s", ldap.EscapeFilter(username), -1),
}
a.log.Debug("Ldap Search For User Request", "info", spew.Sdump(searchReq))
diff --git a/pkg/login/ldap_test.go b/pkg/login/ldap_test.go
index f1cf44dc554..c02fa02e030 100644
--- a/pkg/login/ldap_test.go
+++ b/pkg/login/ldap_test.go
@@ -6,6 +6,7 @@ import (
"testing"
"github.com/grafana/grafana/pkg/bus"
+ "github.com/grafana/grafana/pkg/log"
m "github.com/grafana/grafana/pkg/models"
. "github.com/smartystreets/goconvey/convey"
"gopkg.in/ldap.v3"
@@ -322,11 +323,51 @@ func TestLdapAuther(t *testing.T) {
So(sc.addOrgUserCmd.Role, ShouldEqual, "Admin")
})
})
+
+ Convey("When searching for a user and not all five attributes are mapped", t, func() {
+ mockLdapConnection := &mockLdapConn{}
+ entry := ldap.Entry{
+ DN: "dn", Attributes: []*ldap.EntryAttribute{
+ {Name: "username", Values: []string{"roelgerrits"}},
+ {Name: "surname", Values: []string{"Gerrits"}},
+ {Name: "email", Values: []string{"roel@test.com"}},
+ {Name: "name", Values: []string{"Roel"}},
+ {Name: "memberof", Values: []string{"admins"}},
+ }}
+ result := ldap.SearchResult{Entries: []*ldap.Entry{&entry}}
+ mockLdapConnection.setSearchResult(&result)
+
+ // Set up attribute map without surname and email
+ ldapAuther := &ldapAuther{
+ server: &LdapServerConf{
+ Attr: LdapAttributeMap{
+ Username: "username",
+ Name: "name",
+ MemberOf: "memberof",
+ },
+ SearchBaseDNs: []string{"BaseDNHere"},
+ },
+ conn: mockLdapConnection,
+ log: log.New("test-logger"),
+ }
+
+ searchResult, err := ldapAuther.searchForUser("roelgerrits")
+
+ So(err, ShouldBeNil)
+ So(searchResult, ShouldNotBeNil)
+
+ // User should be searched in ldap
+ So(mockLdapConnection.searchCalled, ShouldBeTrue)
+
+ // No empty attributes should be added to the search request
+ So(len(mockLdapConnection.searchAttributes), ShouldEqual, 3)
+ })
}
type mockLdapConn struct {
- result *ldap.SearchResult
- searchCalled bool
+ result *ldap.SearchResult
+ searchCalled bool
+ searchAttributes []string
}
func (c *mockLdapConn) Bind(username, password string) error {
@@ -339,8 +380,9 @@ func (c *mockLdapConn) setSearchResult(result *ldap.SearchResult) {
c.result = result
}
-func (c *mockLdapConn) Search(*ldap.SearchRequest) (*ldap.SearchResult, error) {
+func (c *mockLdapConn) Search(sr *ldap.SearchRequest) (*ldap.SearchResult, error) {
c.searchCalled = true
+ c.searchAttributes = sr.Attributes
return c.result, nil
}
diff --git a/pkg/metrics/metrics.go b/pkg/metrics/metrics.go
index 326514a9687..bab2fb45127 100644
--- a/pkg/metrics/metrics.go
+++ b/pkg/metrics/metrics.go
@@ -1,17 +1,10 @@
package metrics
import (
- "bytes"
- "encoding/json"
- "net/http"
"runtime"
- "strings"
- "time"
- "github.com/grafana/grafana/pkg/bus"
- "github.com/grafana/grafana/pkg/models"
- "github.com/grafana/grafana/pkg/plugins"
"github.com/grafana/grafana/pkg/setting"
+
"github.com/prometheus/client_golang/prometheus"
)
@@ -68,23 +61,6 @@ var (
grafanaBuildVersion *prometheus.GaugeVec
)
-func newCounterVecStartingAtZero(opts prometheus.CounterOpts, labels []string, labelValues ...string) *prometheus.CounterVec {
- counter := prometheus.NewCounterVec(opts, labels)
-
- for _, label := range labelValues {
- counter.WithLabelValues(label).Add(0)
- }
-
- return counter
-}
-
-func newCounterStartingAtZero(opts prometheus.CounterOpts, labelValues ...string) prometheus.Counter {
- counter := prometheus.NewCounter(opts)
- counter.Add(0)
-
- return counter
-}
-
func init() {
M_Instance_Start = prometheus.NewCounter(prometheus.CounterOpts{
Name: "instance_start_total",
@@ -308,7 +284,7 @@ func init() {
Name: "build_info",
Help: "A metric with a constant '1' value labeled by version, revision, branch, and goversion from which Grafana was built.",
Namespace: exporterName,
- }, []string{"version", "revision", "branch", "goversion"})
+ }, []string{"version", "revision", "branch", "goversion", "edition"})
}
// SetBuildInformation sets the build information for this binary
@@ -317,8 +293,13 @@ func SetBuildInformation(version, revision, branch string) {
// Once this have been released for some time we should be able to remote `M_Grafana_Version`
// The reason we added a new one is that its common practice in the prometheus community
// to name this metric `*_build_info` so its easy to do aggregation on all programs.
+ edition := "oss"
+ if setting.IsEnterprise {
+ edition = "enterprise"
+ }
+
M_Grafana_Version.WithLabelValues(version).Set(1)
- grafanaBuildVersion.WithLabelValues(version, revision, branch, runtime.Version()).Set(1)
+ grafanaBuildVersion.WithLabelValues(version, revision, branch, runtime.Version(), edition).Set(1)
}
func initMetricVars() {
@@ -362,154 +343,19 @@ func initMetricVars() {
}
-func updateTotalStats() {
- statsQuery := models.GetSystemStatsQuery{}
- if err := bus.Dispatch(&statsQuery); err != nil {
- metricsLogger.Error("Failed to get system stats", "error", err)
- return
+func newCounterVecStartingAtZero(opts prometheus.CounterOpts, labels []string, labelValues ...string) *prometheus.CounterVec {
+ counter := prometheus.NewCounterVec(opts, labels)
+
+ for _, label := range labelValues {
+ counter.WithLabelValues(label).Add(0)
}
- M_StatTotal_Dashboards.Set(float64(statsQuery.Result.Dashboards))
- M_StatTotal_Users.Set(float64(statsQuery.Result.Users))
- M_StatActive_Users.Set(float64(statsQuery.Result.ActiveUsers))
- M_StatTotal_Playlists.Set(float64(statsQuery.Result.Playlists))
- M_StatTotal_Orgs.Set(float64(statsQuery.Result.Orgs))
+ return counter
}
-var usageStatsURL = "https://stats.grafana.org/grafana-usage-report"
+func newCounterStartingAtZero(opts prometheus.CounterOpts, labelValues ...string) prometheus.Counter {
+ counter := prometheus.NewCounter(opts)
+ counter.Add(0)
-func getEdition() string {
- if setting.IsEnterprise {
- return "enterprise"
- } else {
- return "oss"
- }
-}
-
-func sendUsageStats(oauthProviders map[string]bool) {
- if !setting.ReportingEnabled {
- return
- }
-
- metricsLogger.Debug("Sending anonymous usage stats to stats.grafana.org")
-
- version := strings.Replace(setting.BuildVersion, ".", "_", -1)
-
- metrics := map[string]interface{}{}
- report := map[string]interface{}{
- "version": version,
- "metrics": metrics,
- "os": runtime.GOOS,
- "arch": runtime.GOARCH,
- "edition": getEdition(),
- "packaging": setting.Packaging,
- }
-
- statsQuery := models.GetSystemStatsQuery{}
- if err := bus.Dispatch(&statsQuery); err != nil {
- metricsLogger.Error("Failed to get system stats", "error", err)
- return
- }
-
- metrics["stats.dashboards.count"] = statsQuery.Result.Dashboards
- metrics["stats.users.count"] = statsQuery.Result.Users
- metrics["stats.orgs.count"] = statsQuery.Result.Orgs
- metrics["stats.playlist.count"] = statsQuery.Result.Playlists
- metrics["stats.plugins.apps.count"] = len(plugins.Apps)
- metrics["stats.plugins.panels.count"] = len(plugins.Panels)
- metrics["stats.plugins.datasources.count"] = len(plugins.DataSources)
- metrics["stats.alerts.count"] = statsQuery.Result.Alerts
- metrics["stats.active_users.count"] = statsQuery.Result.ActiveUsers
- metrics["stats.datasources.count"] = statsQuery.Result.Datasources
- metrics["stats.stars.count"] = statsQuery.Result.Stars
- metrics["stats.folders.count"] = statsQuery.Result.Folders
- metrics["stats.dashboard_permissions.count"] = statsQuery.Result.DashboardPermissions
- metrics["stats.folder_permissions.count"] = statsQuery.Result.FolderPermissions
- metrics["stats.provisioned_dashboards.count"] = statsQuery.Result.ProvisionedDashboards
- metrics["stats.snapshots.count"] = statsQuery.Result.Snapshots
- metrics["stats.teams.count"] = statsQuery.Result.Teams
-
- dsStats := models.GetDataSourceStatsQuery{}
- if err := bus.Dispatch(&dsStats); err != nil {
- metricsLogger.Error("Failed to get datasource stats", "error", err)
- return
- }
-
- // send counters for each data source
- // but ignore any custom data sources
- // as sending that name could be sensitive information
- dsOtherCount := 0
- for _, dsStat := range dsStats.Result {
- if models.IsKnownDataSourcePlugin(dsStat.Type) {
- metrics["stats.ds."+dsStat.Type+".count"] = dsStat.Count
- } else {
- dsOtherCount += dsStat.Count
- }
- }
- metrics["stats.ds.other.count"] = dsOtherCount
-
- metrics["stats.packaging."+setting.Packaging+".count"] = 1
-
- dsAccessStats := models.GetDataSourceAccessStatsQuery{}
- if err := bus.Dispatch(&dsAccessStats); err != nil {
- metricsLogger.Error("Failed to get datasource access stats", "error", err)
- return
- }
-
- // send access counters for each data source
- // but ignore any custom data sources
- // as sending that name could be sensitive information
- dsAccessOtherCount := make(map[string]int64)
- for _, dsAccessStat := range dsAccessStats.Result {
- if dsAccessStat.Access == "" {
- continue
- }
-
- access := strings.ToLower(dsAccessStat.Access)
-
- if models.IsKnownDataSourcePlugin(dsAccessStat.Type) {
- metrics["stats.ds_access."+dsAccessStat.Type+"."+access+".count"] = dsAccessStat.Count
- } else {
- old := dsAccessOtherCount[access]
- dsAccessOtherCount[access] = old + dsAccessStat.Count
- }
- }
-
- for access, count := range dsAccessOtherCount {
- metrics["stats.ds_access.other."+access+".count"] = count
- }
-
- anStats := models.GetAlertNotifierUsageStatsQuery{}
- if err := bus.Dispatch(&anStats); err != nil {
- metricsLogger.Error("Failed to get alert notification stats", "error", err)
- return
- }
-
- for _, stats := range anStats.Result {
- metrics["stats.alert_notifiers."+stats.Type+".count"] = stats.Count
- }
-
- authTypes := map[string]bool{}
- authTypes["anonymous"] = setting.AnonymousEnabled
- authTypes["basic_auth"] = setting.BasicAuthEnabled
- authTypes["ldap"] = setting.LdapEnabled
- authTypes["auth_proxy"] = setting.AuthProxyEnabled
-
- for provider, enabled := range oauthProviders {
- authTypes["oauth_"+provider] = enabled
- }
-
- for authType, enabled := range authTypes {
- enabledValue := 0
- if enabled {
- enabledValue = 1
- }
- metrics["stats.auth_enabled."+authType+".count"] = enabledValue
- }
-
- out, _ := json.MarshalIndent(report, "", " ")
- data := bytes.NewBuffer(out)
-
- client := http.Client{Timeout: 5 * time.Second}
- go client.Post(usageStatsURL, "application/json", data)
+ return counter
}
diff --git a/pkg/metrics/service.go b/pkg/metrics/service.go
index d2c0c815da9..44b83187cac 100644
--- a/pkg/metrics/service.go
+++ b/pkg/metrics/service.go
@@ -2,7 +2,6 @@ package metrics
import (
"context"
- "time"
"github.com/grafana/grafana/pkg/log"
"github.com/grafana/grafana/pkg/metrics/graphitebridge"
@@ -30,7 +29,6 @@ type InternalMetricsService struct {
intervalSeconds int64
graphiteCfg *graphitebridge.Config
- oauthProviders map[string]bool
}
func (im *InternalMetricsService) Init() error {
@@ -50,22 +48,6 @@ func (im *InternalMetricsService) Run(ctx context.Context) error {
M_Instance_Start.Inc()
- // set the total stats gauges before we publishing metrics
- updateTotalStats()
-
- onceEveryDayTick := time.NewTicker(time.Hour * 24)
- everyMinuteTicker := time.NewTicker(time.Minute)
- defer onceEveryDayTick.Stop()
- defer everyMinuteTicker.Stop()
-
- for {
- select {
- case <-onceEveryDayTick.C:
- sendUsageStats(im.oauthProviders)
- case <-everyMinuteTicker.C:
- updateTotalStats()
- case <-ctx.Done():
- return ctx.Err()
- }
- }
+ <-ctx.Done()
+ return ctx.Err()
}
diff --git a/pkg/metrics/settings.go b/pkg/metrics/settings.go
index 18b9e78d6ff..048e4134690 100644
--- a/pkg/metrics/settings.go
+++ b/pkg/metrics/settings.go
@@ -5,8 +5,6 @@ import (
"strings"
"time"
- "github.com/grafana/grafana/pkg/social"
-
"github.com/grafana/grafana/pkg/metrics/graphitebridge"
"github.com/grafana/grafana/pkg/setting"
"github.com/prometheus/client_golang/prometheus"
@@ -24,8 +22,6 @@ func (im *InternalMetricsService) readSettings() error {
return fmt.Errorf("Unable to parse metrics graphite section, %v", err)
}
- im.oauthProviders = social.GetOAuthProviders(im.Cfg)
-
return nil
}
diff --git a/pkg/middleware/middleware.go b/pkg/middleware/middleware.go
index 3722ac3058f..fa335eb10d9 100644
--- a/pkg/middleware/middleware.go
+++ b/pkg/middleware/middleware.go
@@ -1,13 +1,15 @@
package middleware
import (
+ "net/http"
+ "net/url"
"strconv"
+ "time"
"github.com/grafana/grafana/pkg/bus"
"github.com/grafana/grafana/pkg/components/apikeygen"
"github.com/grafana/grafana/pkg/log"
m "github.com/grafana/grafana/pkg/models"
- "github.com/grafana/grafana/pkg/services/auth"
"github.com/grafana/grafana/pkg/services/session"
"github.com/grafana/grafana/pkg/setting"
"github.com/grafana/grafana/pkg/util"
@@ -21,7 +23,7 @@ var (
ReqOrgAdmin = RoleAuth(m.ROLE_ADMIN)
)
-func GetContextHandler(ats auth.UserAuthTokenService) macaron.Handler {
+func GetContextHandler(ats m.UserTokenService) macaron.Handler {
return func(c *macaron.Context) {
ctx := &m.ReqContext{
Context: c,
@@ -49,7 +51,7 @@ func GetContextHandler(ats auth.UserAuthTokenService) macaron.Handler {
case initContextWithApiKey(ctx):
case initContextWithBasicAuth(ctx, orgId):
case initContextWithAuthProxy(ctx, orgId):
- case ats.InitContextWithToken(ctx, orgId):
+ case initContextWithToken(ats, ctx, orgId):
case initContextWithAnonymousUser(ctx):
}
@@ -166,6 +168,69 @@ func initContextWithBasicAuth(ctx *m.ReqContext, orgId int64) bool {
return true
}
+func initContextWithToken(authTokenService m.UserTokenService, ctx *m.ReqContext, orgID int64) bool {
+ rawToken := ctx.GetCookie(setting.LoginCookieName)
+ if rawToken == "" {
+ return false
+ }
+
+ token, err := authTokenService.LookupToken(rawToken)
+ if err != nil {
+ ctx.Logger.Error("failed to look up user based on cookie", "error", err)
+ WriteSessionCookie(ctx, "", -1)
+ return false
+ }
+
+ query := m.GetSignedInUserQuery{UserId: token.UserId, OrgId: orgID}
+ if err := bus.Dispatch(&query); err != nil {
+ ctx.Logger.Error("failed to get user with id", "userId", token.UserId, "error", err)
+ return false
+ }
+
+ ctx.SignedInUser = query.Result
+ ctx.IsSignedIn = true
+ ctx.UserToken = token
+
+ rotated, err := authTokenService.TryRotateToken(token, ctx.RemoteAddr(), ctx.Req.UserAgent())
+ if err != nil {
+ ctx.Logger.Error("failed to rotate token", "error", err)
+ return true
+ }
+
+ if rotated {
+ WriteSessionCookie(ctx, token.UnhashedToken, setting.LoginMaxLifetimeDays)
+ }
+
+ return true
+}
+
+func WriteSessionCookie(ctx *m.ReqContext, value string, maxLifetimeDays int) {
+ if setting.Env == setting.DEV {
+ ctx.Logger.Info("new token", "unhashed token", value)
+ }
+
+ var maxAge int
+ if maxLifetimeDays <= 0 {
+ maxAge = -1
+ } else {
+ maxAgeHours := (time.Duration(setting.LoginMaxLifetimeDays) * 24 * time.Hour) + time.Hour
+ maxAge = int(maxAgeHours.Seconds())
+ }
+
+ ctx.Resp.Header().Del("Set-Cookie")
+ cookie := http.Cookie{
+ Name: setting.LoginCookieName,
+ Value: url.QueryEscape(value),
+ HttpOnly: true,
+ Path: setting.AppSubUrl + "/",
+ Secure: setting.CookieSecure,
+ MaxAge: maxAge,
+ SameSite: setting.CookieSameSite,
+ }
+
+ http.SetCookie(ctx.Resp, &cookie)
+}
+
func AddDefaultResponseHeaders() macaron.Handler {
return func(ctx *m.ReqContext) {
if ctx.IsApiRequest() && ctx.Req.Method == "GET" {
diff --git a/pkg/middleware/middleware_test.go b/pkg/middleware/middleware_test.go
index 4679c449853..8545c3856c9 100644
--- a/pkg/middleware/middleware_test.go
+++ b/pkg/middleware/middleware_test.go
@@ -6,6 +6,7 @@ import (
"net/http/httptest"
"path/filepath"
"testing"
+ "time"
msession "github.com/go-macaron/session"
"github.com/grafana/grafana/pkg/bus"
@@ -146,17 +147,95 @@ func TestMiddlewareContext(t *testing.T) {
})
})
- middlewareScenario("Auth token service", func(sc *scenarioContext) {
- var wasCalled bool
- sc.userAuthTokenService.initContextWithTokenProvider = func(ctx *m.ReqContext, orgId int64) bool {
- wasCalled = true
- return false
+ middlewareScenario("Non-expired auth token in cookie which not are being rotated", func(sc *scenarioContext) {
+ sc.withTokenSessionCookie("token")
+
+ bus.AddHandler("test", func(query *m.GetSignedInUserQuery) error {
+ query.Result = &m.SignedInUser{OrgId: 2, UserId: 12}
+ return nil
+ })
+
+ sc.userAuthTokenService.lookupTokenProvider = func(unhashedToken string) (*m.UserToken, error) {
+ return &m.UserToken{
+ UserId: 12,
+ UnhashedToken: unhashedToken,
+ }, nil
}
sc.fakeReq("GET", "/").exec()
- Convey("should call middleware", func() {
- So(wasCalled, ShouldBeTrue)
+ Convey("should init context with user info", func() {
+ So(sc.context.IsSignedIn, ShouldBeTrue)
+ So(sc.context.UserId, ShouldEqual, 12)
+ So(sc.context.UserToken.UserId, ShouldEqual, 12)
+ So(sc.context.UserToken.UnhashedToken, ShouldEqual, "token")
+ })
+
+ Convey("should not set cookie", func() {
+ So(sc.resp.Header().Get("Set-Cookie"), ShouldEqual, "")
+ })
+ })
+
+ middlewareScenario("Non-expired auth token in cookie which are being rotated", func(sc *scenarioContext) {
+ sc.withTokenSessionCookie("token")
+
+ bus.AddHandler("test", func(query *m.GetSignedInUserQuery) error {
+ query.Result = &m.SignedInUser{OrgId: 2, UserId: 12}
+ return nil
+ })
+
+ sc.userAuthTokenService.lookupTokenProvider = func(unhashedToken string) (*m.UserToken, error) {
+ return &m.UserToken{
+ UserId: 12,
+ UnhashedToken: "",
+ }, nil
+ }
+
+ sc.userAuthTokenService.tryRotateTokenProvider = func(userToken *m.UserToken, clientIP, userAgent string) (bool, error) {
+ userToken.UnhashedToken = "rotated"
+ return true, nil
+ }
+
+ maxAgeHours := (time.Duration(setting.LoginMaxLifetimeDays) * 24 * time.Hour)
+ maxAge := (maxAgeHours + time.Hour).Seconds()
+
+ expectedCookie := &http.Cookie{
+ Name: setting.LoginCookieName,
+ Value: "rotated",
+ Path: setting.AppSubUrl + "/",
+ HttpOnly: true,
+ MaxAge: int(maxAge),
+ Secure: setting.CookieSecure,
+ SameSite: setting.CookieSameSite,
+ }
+
+ sc.fakeReq("GET", "/").exec()
+
+ Convey("should init context with user info", func() {
+ So(sc.context.IsSignedIn, ShouldBeTrue)
+ So(sc.context.UserId, ShouldEqual, 12)
+ So(sc.context.UserToken.UserId, ShouldEqual, 12)
+ So(sc.context.UserToken.UnhashedToken, ShouldEqual, "rotated")
+ })
+
+ Convey("should set cookie", func() {
+ So(sc.resp.Header().Get("Set-Cookie"), ShouldEqual, expectedCookie.String())
+ })
+ })
+
+ middlewareScenario("Invalid/expired auth token in cookie", func(sc *scenarioContext) {
+ sc.withTokenSessionCookie("token")
+
+ sc.userAuthTokenService.lookupTokenProvider = func(unhashedToken string) (*m.UserToken, error) {
+ return nil, m.ErrUserTokenNotFound
+ }
+
+ sc.fakeReq("GET", "/").exec()
+
+ Convey("should not init context with user info", func() {
+ So(sc.context.IsSignedIn, ShouldBeFalse)
+ So(sc.context.UserId, ShouldEqual, 0)
+ So(sc.context.UserToken, ShouldBeNil)
})
})
@@ -469,6 +548,9 @@ func middlewareScenario(desc string, fn scenarioFunc) {
Convey(desc, func() {
defer bus.ClearBusHandlers()
+ setting.LoginCookieName = "grafana_session"
+ setting.LoginMaxLifetimeDays = 30
+
sc := &scenarioContext{}
viewsPath, _ := filepath.Abs("../../public/views")
@@ -508,6 +590,7 @@ type scenarioContext struct {
resp *httptest.ResponseRecorder
apiKey string
authHeader string
+ tokenSessionCookie string
respJson map[string]interface{}
handlerFunc handlerFunc
defaultHandler macaron.Handler
@@ -522,6 +605,11 @@ func (sc *scenarioContext) withValidApiKey() *scenarioContext {
return sc
}
+func (sc *scenarioContext) withTokenSessionCookie(unhashedToken string) *scenarioContext {
+ sc.tokenSessionCookie = unhashedToken
+ return sc
+}
+
func (sc *scenarioContext) withAuthorizationHeader(authHeader string) *scenarioContext {
sc.authHeader = authHeader
return sc
@@ -571,6 +659,13 @@ func (sc *scenarioContext) exec() {
sc.req.Header.Add("Authorization", sc.authHeader)
}
+ if sc.tokenSessionCookie != "" {
+ sc.req.AddCookie(&http.Cookie{
+ Name: setting.LoginCookieName,
+ Value: sc.tokenSessionCookie,
+ })
+ }
+
sc.m.ServeHTTP(sc.resp, sc.req)
if sc.resp.Header().Get("Content-Type") == "application/json; charset=UTF-8" {
@@ -583,23 +678,47 @@ type scenarioFunc func(c *scenarioContext)
type handlerFunc func(c *m.ReqContext)
type fakeUserAuthTokenService struct {
- initContextWithTokenProvider func(ctx *m.ReqContext, orgID int64) bool
+ createTokenProvider func(userId int64, clientIP, userAgent string) (*m.UserToken, error)
+ tryRotateTokenProvider func(token *m.UserToken, clientIP, userAgent string) (bool, error)
+ lookupTokenProvider func(unhashedToken string) (*m.UserToken, error)
+ revokeTokenProvider func(token *m.UserToken) error
}
func newFakeUserAuthTokenService() *fakeUserAuthTokenService {
return &fakeUserAuthTokenService{
- initContextWithTokenProvider: func(ctx *m.ReqContext, orgID int64) bool {
- return false
+ createTokenProvider: func(userId int64, clientIP, userAgent string) (*m.UserToken, error) {
+ return &m.UserToken{
+ UserId: 0,
+ UnhashedToken: "",
+ }, nil
+ },
+ tryRotateTokenProvider: func(token *m.UserToken, clientIP, userAgent string) (bool, error) {
+ return false, nil
+ },
+ lookupTokenProvider: func(unhashedToken string) (*m.UserToken, error) {
+ return &m.UserToken{
+ UserId: 0,
+ UnhashedToken: "",
+ }, nil
+ },
+ revokeTokenProvider: func(token *m.UserToken) error {
+ return nil
},
}
}
-func (s *fakeUserAuthTokenService) InitContextWithToken(ctx *m.ReqContext, orgID int64) bool {
- return s.initContextWithTokenProvider(ctx, orgID)
+func (s *fakeUserAuthTokenService) CreateToken(userId int64, clientIP, userAgent string) (*m.UserToken, error) {
+ return s.createTokenProvider(userId, clientIP, userAgent)
}
-func (s *fakeUserAuthTokenService) UserAuthenticatedHook(user *m.User, c *m.ReqContext) error {
- return nil
+func (s *fakeUserAuthTokenService) LookupToken(unhashedToken string) (*m.UserToken, error) {
+ return s.lookupTokenProvider(unhashedToken)
}
-func (s *fakeUserAuthTokenService) SignOutUser(c *m.ReqContext) error { return nil }
+func (s *fakeUserAuthTokenService) TryRotateToken(token *m.UserToken, clientIP, userAgent string) (bool, error) {
+ return s.tryRotateTokenProvider(token, clientIP, userAgent)
+}
+
+func (s *fakeUserAuthTokenService) RevokeToken(token *m.UserToken) error {
+ return s.revokeTokenProvider(token)
+}
diff --git a/pkg/middleware/org_redirect_test.go b/pkg/middleware/org_redirect_test.go
index 46b8776fdcc..e01d1a68d21 100644
--- a/pkg/middleware/org_redirect_test.go
+++ b/pkg/middleware/org_redirect_test.go
@@ -14,14 +14,21 @@ func TestOrgRedirectMiddleware(t *testing.T) {
Convey("Can redirect to correct org", t, func() {
middlewareScenario("when setting a correct org for the user", func(sc *scenarioContext) {
+ sc.withTokenSessionCookie("token")
bus.AddHandler("test", func(query *m.SetUsingOrgCommand) error {
return nil
})
- sc.userAuthTokenService.initContextWithTokenProvider = func(ctx *m.ReqContext, orgId int64) bool {
- ctx.SignedInUser = &m.SignedInUser{OrgId: 1, UserId: 12}
- ctx.IsSignedIn = true
- return true
+ bus.AddHandler("test", func(query *m.GetSignedInUserQuery) error {
+ query.Result = &m.SignedInUser{OrgId: 1, UserId: 12}
+ return nil
+ })
+
+ sc.userAuthTokenService.lookupTokenProvider = func(unhashedToken string) (*m.UserToken, error) {
+ return &m.UserToken{
+ UserId: 0,
+ UnhashedToken: "",
+ }, nil
}
sc.m.Get("/", sc.defaultHandler)
@@ -33,21 +40,23 @@ func TestOrgRedirectMiddleware(t *testing.T) {
})
middlewareScenario("when setting an invalid org for user", func(sc *scenarioContext) {
+ sc.withTokenSessionCookie("token")
bus.AddHandler("test", func(query *m.SetUsingOrgCommand) error {
return fmt.Errorf("")
})
- sc.userAuthTokenService.initContextWithTokenProvider = func(ctx *m.ReqContext, orgId int64) bool {
- ctx.SignedInUser = &m.SignedInUser{OrgId: 1, UserId: 12}
- ctx.IsSignedIn = true
- return true
- }
-
bus.AddHandler("test", func(query *m.GetSignedInUserQuery) error {
query.Result = &m.SignedInUser{OrgId: 1, UserId: 12}
return nil
})
+ sc.userAuthTokenService.lookupTokenProvider = func(unhashedToken string) (*m.UserToken, error) {
+ return &m.UserToken{
+ UserId: 12,
+ UnhashedToken: "",
+ }, nil
+ }
+
sc.m.Get("/", sc.defaultHandler)
sc.fakeReq("GET", "/?orgId=3").exec()
diff --git a/pkg/middleware/quota_test.go b/pkg/middleware/quota_test.go
index 4f2203a5d3d..e2a6ef63377 100644
--- a/pkg/middleware/quota_test.go
+++ b/pkg/middleware/quota_test.go
@@ -74,10 +74,17 @@ func TestMiddlewareQuota(t *testing.T) {
})
middlewareScenario("with user logged in", func(sc *scenarioContext) {
- sc.userAuthTokenService.initContextWithTokenProvider = func(ctx *m.ReqContext, orgId int64) bool {
- ctx.SignedInUser = &m.SignedInUser{OrgId: 2, UserId: 12}
- ctx.IsSignedIn = true
- return true
+ sc.withTokenSessionCookie("token")
+ bus.AddHandler("test", func(query *m.GetSignedInUserQuery) error {
+ query.Result = &m.SignedInUser{OrgId: 2, UserId: 12}
+ return nil
+ })
+
+ sc.userAuthTokenService.lookupTokenProvider = func(unhashedToken string) (*m.UserToken, error) {
+ return &m.UserToken{
+ UserId: 12,
+ UnhashedToken: "",
+ }, nil
}
bus.AddHandler("globalQuota", func(query *m.GetGlobalQuotaByTargetQuery) error {
diff --git a/pkg/models/context.go b/pkg/models/context.go
index df970451304..b0c6ec9226d 100644
--- a/pkg/models/context.go
+++ b/pkg/models/context.go
@@ -13,6 +13,7 @@ import (
type ReqContext struct {
*macaron.Context
*SignedInUser
+ UserToken *UserToken
// This should only be used by the auth_proxy
Session session.SessionStore
diff --git a/pkg/models/datasource.go b/pkg/models/datasource.go
index e1cb185d92a..22c53dfa0dd 100644
--- a/pkg/models/datasource.go
+++ b/pkg/models/datasource.go
@@ -23,7 +23,7 @@ const (
DS_ACCESS_DIRECT = "direct"
DS_ACCESS_PROXY = "proxy"
DS_STACKDRIVER = "stackdriver"
- DS_AZURE_MONITOR = "azure-monitor"
+ DS_AZURE_MONITOR = "grafana-azure-monitor-datasource"
)
var (
diff --git a/pkg/models/datasource_cache.go b/pkg/models/datasource_cache.go
index 66ba66e4d39..864adb4a5a6 100644
--- a/pkg/models/datasource_cache.go
+++ b/pkg/models/datasource_cache.go
@@ -8,6 +8,8 @@ import (
"net/http"
"sync"
"time"
+
+ "github.com/grafana/grafana/pkg/setting"
)
type proxyTransportCache struct {
@@ -46,21 +48,18 @@ func (ds *DataSource) GetHttpTransport() (*http.Transport, error) {
return t.Transport, nil
}
- var tlsSkipVerify, tlsClientAuth, tlsAuthWithCACert bool
- if ds.JsonData != nil {
- tlsClientAuth = ds.JsonData.Get("tlsAuth").MustBool(false)
- tlsAuthWithCACert = ds.JsonData.Get("tlsAuthWithCACert").MustBool(false)
- tlsSkipVerify = ds.JsonData.Get("tlsSkipVerify").MustBool(false)
+ tlsConfig, err := ds.GetTLSConfig()
+ if err != nil {
+ return nil, err
}
+ tlsConfig.Renegotiation = tls.RenegotiateFreelyAsClient
+
transport := &http.Transport{
- TLSClientConfig: &tls.Config{
- InsecureSkipVerify: tlsSkipVerify,
- Renegotiation: tls.RenegotiateFreelyAsClient,
- },
- Proxy: http.ProxyFromEnvironment,
+ TLSClientConfig: tlsConfig,
+ Proxy: http.ProxyFromEnvironment,
Dial: (&net.Dialer{
- Timeout: 30 * time.Second,
+ Timeout: time.Duration(setting.DataProxyTimeout) * time.Second,
KeepAlive: 30 * time.Second,
DualStack: true,
}).Dial,
@@ -70,6 +69,26 @@ func (ds *DataSource) GetHttpTransport() (*http.Transport, error) {
IdleConnTimeout: 90 * time.Second,
}
+ ptc.cache[ds.Id] = cachedTransport{
+ Transport: transport,
+ updated: ds.Updated,
+ }
+
+ return transport, nil
+}
+
+func (ds *DataSource) GetTLSConfig() (*tls.Config, error) {
+ var tlsSkipVerify, tlsClientAuth, tlsAuthWithCACert bool
+ if ds.JsonData != nil {
+ tlsClientAuth = ds.JsonData.Get("tlsAuth").MustBool(false)
+ tlsAuthWithCACert = ds.JsonData.Get("tlsAuthWithCACert").MustBool(false)
+ tlsSkipVerify = ds.JsonData.Get("tlsSkipVerify").MustBool(false)
+ }
+
+ tlsConfig := &tls.Config{
+ InsecureSkipVerify: tlsSkipVerify,
+ }
+
if tlsClientAuth || tlsAuthWithCACert {
decrypted := ds.SecureJsonData.Decrypt()
if tlsAuthWithCACert && len(decrypted["tlsCACert"]) > 0 {
@@ -78,7 +97,7 @@ func (ds *DataSource) GetHttpTransport() (*http.Transport, error) {
if !ok {
return nil, errors.New("Failed to parse TLS CA PEM certificate")
}
- transport.TLSClientConfig.RootCAs = caPool
+ tlsConfig.RootCAs = caPool
}
if tlsClientAuth {
@@ -86,14 +105,9 @@ func (ds *DataSource) GetHttpTransport() (*http.Transport, error) {
if err != nil {
return nil, err
}
- transport.TLSClientConfig.Certificates = []tls.Certificate{cert}
+ tlsConfig.Certificates = []tls.Certificate{cert}
}
}
- ptc.cache[ds.Id] = cachedTransport{
- Transport: transport,
- updated: ds.Updated,
- }
-
- return transport, nil
+ return tlsConfig, nil
}
diff --git a/pkg/models/stats.go b/pkg/models/stats.go
index d3e145dedf4..0edd204ec03 100644
--- a/pkg/models/stats.go
+++ b/pkg/models/stats.go
@@ -15,6 +15,7 @@ type SystemStats struct {
FolderPermissions int64
Folders int64
ProvisionedDashboards int64
+ AuthTokens int64
}
type DataSourceStats struct {
diff --git a/pkg/models/user_token.go b/pkg/models/user_token.go
new file mode 100644
index 00000000000..c8084cf1eba
--- /dev/null
+++ b/pkg/models/user_token.go
@@ -0,0 +1,32 @@
+package models
+
+import "errors"
+
+// Typed errors
+var (
+ ErrUserTokenNotFound = errors.New("user token not found")
+)
+
+// UserToken represents a user token
+type UserToken struct {
+ Id int64
+ UserId int64
+ AuthToken string
+ PrevAuthToken string
+ UserAgent string
+ ClientIp string
+ AuthTokenSeen bool
+ SeenAt int64
+ RotatedAt int64
+ CreatedAt int64
+ UpdatedAt int64
+ UnhashedToken string
+}
+
+// UserTokenService are used for generating and validating user tokens
+type UserTokenService interface {
+ CreateToken(userId int64, clientIP, userAgent string) (*UserToken, error)
+ LookupToken(unhashedToken string) (*UserToken, error)
+ TryRotateToken(token *UserToken, clientIP, userAgent string) (bool, error)
+ RevokeToken(token *UserToken) error
+}
diff --git a/pkg/services/auth/auth_token.go b/pkg/services/auth/auth_token.go
index 13b9ef607f5..ef5dccd779f 100644
--- a/pkg/services/auth/auth_token.go
+++ b/pkg/services/auth/auth_token.go
@@ -3,13 +3,10 @@ package auth
import (
"crypto/sha256"
"encoding/hex"
- "errors"
- "net/http"
- "net/url"
"time"
- "github.com/grafana/grafana/pkg/bus"
"github.com/grafana/grafana/pkg/infra/serverlock"
+
"github.com/grafana/grafana/pkg/log"
"github.com/grafana/grafana/pkg/models"
"github.com/grafana/grafana/pkg/registry"
@@ -19,116 +16,26 @@ import (
)
func init() {
- registry.RegisterService(&UserAuthTokenServiceImpl{})
+ registry.RegisterService(&UserAuthTokenService{})
}
-var (
- getTime = time.Now
- UrgentRotateTime = 1 * time.Minute
- oneYearInSeconds = 31557600 //used as default maxage for session cookies. We validate/rotate them more often.
-)
+var getTime = time.Now
-// UserAuthTokenService are used for generating and validating user auth tokens
-type UserAuthTokenService interface {
- InitContextWithToken(ctx *models.ReqContext, orgID int64) bool
- UserAuthenticatedHook(user *models.User, c *models.ReqContext) error
- SignOutUser(c *models.ReqContext) error
-}
+const urgentRotateTime = 1 * time.Minute
-type UserAuthTokenServiceImpl struct {
+type UserAuthTokenService struct {
SQLStore *sqlstore.SqlStore `inject:""`
ServerLockService *serverlock.ServerLockService `inject:""`
Cfg *setting.Cfg `inject:""`
log log.Logger
}
-// Init this service
-func (s *UserAuthTokenServiceImpl) Init() error {
+func (s *UserAuthTokenService) Init() error {
s.log = log.New("auth")
return nil
}
-func (s *UserAuthTokenServiceImpl) InitContextWithToken(ctx *models.ReqContext, orgID int64) bool {
- //auth User
- unhashedToken := ctx.GetCookie(s.Cfg.LoginCookieName)
- if unhashedToken == "" {
- return false
- }
-
- userToken, err := s.LookupToken(unhashedToken)
- if err != nil {
- ctx.Logger.Info("failed to look up user based on cookie", "error", err)
- return false
- }
-
- query := models.GetSignedInUserQuery{UserId: userToken.UserId, OrgId: orgID}
- if err := bus.Dispatch(&query); err != nil {
- ctx.Logger.Error("Failed to get user with id", "userId", userToken.UserId, "error", err)
- return false
- }
-
- ctx.SignedInUser = query.Result
- ctx.IsSignedIn = true
-
- //rotate session token if needed.
- rotated, err := s.RefreshToken(userToken, ctx.RemoteAddr(), ctx.Req.UserAgent())
- if err != nil {
- ctx.Logger.Error("failed to rotate token", "error", err, "userId", userToken.UserId, "tokenId", userToken.Id)
- return true
- }
-
- if rotated {
- s.writeSessionCookie(ctx, userToken.UnhashedToken, oneYearInSeconds)
- }
-
- return true
-}
-
-func (s *UserAuthTokenServiceImpl) writeSessionCookie(ctx *models.ReqContext, value string, maxAge int) {
- if setting.Env == setting.DEV {
- ctx.Logger.Debug("new token", "unhashed token", value)
- }
-
- ctx.Resp.Header().Del("Set-Cookie")
- cookie := http.Cookie{
- Name: s.Cfg.LoginCookieName,
- Value: url.QueryEscape(value),
- HttpOnly: true,
- Path: setting.AppSubUrl + "/",
- Secure: s.Cfg.SecurityHTTPSCookies,
- MaxAge: maxAge,
- SameSite: s.Cfg.LoginCookieSameSite,
- }
-
- http.SetCookie(ctx.Resp, &cookie)
-}
-
-func (s *UserAuthTokenServiceImpl) UserAuthenticatedHook(user *models.User, c *models.ReqContext) error {
- userToken, err := s.CreateToken(user.Id, c.RemoteAddr(), c.Req.UserAgent())
- if err != nil {
- return err
- }
-
- s.writeSessionCookie(c, userToken.UnhashedToken, oneYearInSeconds)
- return nil
-}
-
-func (s *UserAuthTokenServiceImpl) SignOutUser(c *models.ReqContext) error {
- unhashedToken := c.GetCookie(s.Cfg.LoginCookieName)
- if unhashedToken == "" {
- return errors.New("cannot logout without session token")
- }
-
- hashedToken := hashToken(unhashedToken)
-
- sql := `DELETE FROM user_auth_token WHERE auth_token = ?`
- _, err := s.SQLStore.NewSession().Exec(sql, hashedToken)
-
- s.writeSessionCookie(c, "", -1)
- return err
-}
-
-func (s *UserAuthTokenServiceImpl) CreateToken(userId int64, clientIP, userAgent string) (*userAuthToken, error) {
+func (s *UserAuthTokenService) CreateToken(userId int64, clientIP, userAgent string) (*models.UserToken, error) {
clientIP = util.ParseIPAddress(clientIP)
token, err := util.RandomHex(16)
if err != nil {
@@ -139,7 +46,7 @@ func (s *UserAuthTokenServiceImpl) CreateToken(userId int64, clientIP, userAgent
now := getTime().Unix()
- userToken := userAuthToken{
+ userAuthToken := userAuthToken{
UserId: userId,
AuthToken: hashedToken,
PrevAuthToken: hashedToken,
@@ -151,98 +58,114 @@ func (s *UserAuthTokenServiceImpl) CreateToken(userId int64, clientIP, userAgent
SeenAt: 0,
AuthTokenSeen: false,
}
- _, err = s.SQLStore.NewSession().Insert(&userToken)
+ _, err = s.SQLStore.NewSession().Insert(&userAuthToken)
if err != nil {
return nil, err
}
- userToken.UnhashedToken = token
+ userAuthToken.UnhashedToken = token
- return &userToken, nil
+ s.log.Debug("user auth token created", "tokenId", userAuthToken.Id, "userId", userAuthToken.UserId, "clientIP", userAuthToken.ClientIp, "userAgent", userAuthToken.UserAgent, "authToken", userAuthToken.AuthToken)
+
+ var userToken models.UserToken
+ err = userAuthToken.toUserToken(&userToken)
+
+ return &userToken, err
}
-func (s *UserAuthTokenServiceImpl) LookupToken(unhashedToken string) (*userAuthToken, error) {
+func (s *UserAuthTokenService) LookupToken(unhashedToken string) (*models.UserToken, error) {
hashedToken := hashToken(unhashedToken)
if setting.Env == setting.DEV {
s.log.Debug("looking up token", "unhashed", unhashedToken, "hashed", hashedToken)
}
- expireBefore := getTime().Add(time.Duration(-86400*s.Cfg.LoginCookieMaxDays) * time.Second).Unix()
+ tokenMaxLifetime := time.Duration(s.Cfg.LoginMaxLifetimeDays) * 24 * time.Hour
+ tokenMaxInactiveLifetime := time.Duration(s.Cfg.LoginMaxInactiveLifetimeDays) * 24 * time.Hour
+ createdAfter := getTime().Add(-tokenMaxLifetime).Unix()
+ rotatedAfter := getTime().Add(-tokenMaxInactiveLifetime).Unix()
- var userToken userAuthToken
- exists, err := s.SQLStore.NewSession().Where("(auth_token = ? OR prev_auth_token = ?) AND created_at > ?", hashedToken, hashedToken, expireBefore).Get(&userToken)
+ var model userAuthToken
+ exists, err := s.SQLStore.NewSession().Where("(auth_token = ? OR prev_auth_token = ?) AND created_at > ? AND rotated_at > ?", hashedToken, hashedToken, createdAfter, rotatedAfter).Get(&model)
if err != nil {
return nil, err
}
if !exists {
- return nil, ErrAuthTokenNotFound
+ return nil, models.ErrUserTokenNotFound
}
- if userToken.AuthToken != hashedToken && userToken.PrevAuthToken == hashedToken && userToken.AuthTokenSeen {
- userTokenCopy := userToken
- userTokenCopy.AuthTokenSeen = false
- expireBefore := getTime().Add(-UrgentRotateTime).Unix()
- affectedRows, err := s.SQLStore.NewSession().Where("id = ? AND prev_auth_token = ? AND rotated_at < ?", userTokenCopy.Id, userTokenCopy.PrevAuthToken, expireBefore).AllCols().Update(&userTokenCopy)
+ if model.AuthToken != hashedToken && model.PrevAuthToken == hashedToken && model.AuthTokenSeen {
+ modelCopy := model
+ modelCopy.AuthTokenSeen = false
+ expireBefore := getTime().Add(-urgentRotateTime).Unix()
+ affectedRows, err := s.SQLStore.NewSession().Where("id = ? AND prev_auth_token = ? AND rotated_at < ?", modelCopy.Id, modelCopy.PrevAuthToken, expireBefore).AllCols().Update(&modelCopy)
if err != nil {
return nil, err
}
if affectedRows == 0 {
- s.log.Debug("prev seen token unchanged", "userTokenId", userToken.Id, "userId", userToken.UserId, "authToken", userToken.AuthToken, "clientIP", userToken.ClientIp, "userAgent", userToken.UserAgent)
+ s.log.Debug("prev seen token unchanged", "tokenId", model.Id, "userId", model.UserId, "clientIP", model.ClientIp, "userAgent", model.UserAgent, "authToken", model.AuthToken)
} else {
- s.log.Debug("prev seen token", "userTokenId", userToken.Id, "userId", userToken.UserId, "authToken", userToken.AuthToken, "clientIP", userToken.ClientIp, "userAgent", userToken.UserAgent)
+ s.log.Debug("prev seen token", "tokenId", model.Id, "userId", model.UserId, "clientIP", model.ClientIp, "userAgent", model.UserAgent, "authToken", model.AuthToken)
}
}
- if !userToken.AuthTokenSeen && userToken.AuthToken == hashedToken {
- userTokenCopy := userToken
- userTokenCopy.AuthTokenSeen = true
- userTokenCopy.SeenAt = getTime().Unix()
- affectedRows, err := s.SQLStore.NewSession().Where("id = ? AND auth_token = ?", userTokenCopy.Id, userTokenCopy.AuthToken).AllCols().Update(&userTokenCopy)
+ if !model.AuthTokenSeen && model.AuthToken == hashedToken {
+ modelCopy := model
+ modelCopy.AuthTokenSeen = true
+ modelCopy.SeenAt = getTime().Unix()
+ affectedRows, err := s.SQLStore.NewSession().Where("id = ? AND auth_token = ?", modelCopy.Id, modelCopy.AuthToken).AllCols().Update(&modelCopy)
if err != nil {
return nil, err
}
if affectedRows == 1 {
- userToken = userTokenCopy
+ model = modelCopy
}
if affectedRows == 0 {
- s.log.Debug("seen wrong token", "userTokenId", userToken.Id, "userId", userToken.UserId, "authToken", userToken.AuthToken, "clientIP", userToken.ClientIp, "userAgent", userToken.UserAgent)
+ s.log.Debug("seen wrong token", "tokenId", model.Id, "userId", model.UserId, "clientIP", model.ClientIp, "userAgent", model.UserAgent, "authToken", model.AuthToken)
} else {
- s.log.Debug("seen token", "userTokenId", userToken.Id, "userId", userToken.UserId, "authToken", userToken.AuthToken, "clientIP", userToken.ClientIp, "userAgent", userToken.UserAgent)
+ s.log.Debug("seen token", "tokenId", model.Id, "userId", model.UserId, "clientIP", model.ClientIp, "userAgent", model.UserAgent, "authToken", model.AuthToken)
}
}
- userToken.UnhashedToken = unhashedToken
+ model.UnhashedToken = unhashedToken
- return &userToken, nil
+ var userToken models.UserToken
+ err = model.toUserToken(&userToken)
+
+ return &userToken, err
}
-func (s *UserAuthTokenServiceImpl) RefreshToken(token *userAuthToken, clientIP, userAgent string) (bool, error) {
+func (s *UserAuthTokenService) TryRotateToken(token *models.UserToken, clientIP, userAgent string) (bool, error) {
if token == nil {
return false, nil
}
+ model := userAuthTokenFromUserToken(token)
+
now := getTime()
needsRotation := false
- rotatedAt := time.Unix(token.RotatedAt, 0)
- if token.AuthTokenSeen {
- needsRotation = rotatedAt.Before(now.Add(-time.Duration(s.Cfg.LoginCookieRotation) * time.Minute))
+ rotatedAt := time.Unix(model.RotatedAt, 0)
+ if model.AuthTokenSeen {
+ needsRotation = rotatedAt.Before(now.Add(-time.Duration(s.Cfg.TokenRotationIntervalMinutes) * time.Minute))
} else {
- needsRotation = rotatedAt.Before(now.Add(-UrgentRotateTime))
+ needsRotation = rotatedAt.Before(now.Add(-urgentRotateTime))
}
if !needsRotation {
return false, nil
}
- s.log.Debug("refresh token needs rotation?", "auth_token_seen", token.AuthTokenSeen, "rotated_at", rotatedAt, "token.Id", token.Id)
+ s.log.Debug("token needs rotation", "tokenId", model.Id, "authTokenSeen", model.AuthTokenSeen, "rotatedAt", rotatedAt)
clientIP = util.ParseIPAddress(clientIP)
- newToken, _ := util.RandomHex(16)
+ newToken, err := util.RandomHex(16)
+ if err != nil {
+ return false, err
+ }
hashedToken := hashToken(newToken)
// very important that auth_token_seen is set after the prev_auth_token = case when ... for mysql to function correctly
@@ -258,21 +181,44 @@ func (s *UserAuthTokenServiceImpl) RefreshToken(token *userAuthToken, clientIP,
rotated_at = ?
WHERE id = ? AND (auth_token_seen = ? OR rotated_at < ?)`
- res, err := s.SQLStore.NewSession().Exec(sql, userAgent, clientIP, s.SQLStore.Dialect.BooleanStr(true), hashedToken, s.SQLStore.Dialect.BooleanStr(false), now.Unix(), token.Id, s.SQLStore.Dialect.BooleanStr(true), now.Add(-30*time.Second).Unix())
+ res, err := s.SQLStore.NewSession().Exec(sql, userAgent, clientIP, s.SQLStore.Dialect.BooleanStr(true), hashedToken, s.SQLStore.Dialect.BooleanStr(false), now.Unix(), model.Id, s.SQLStore.Dialect.BooleanStr(true), now.Add(-30*time.Second).Unix())
if err != nil {
return false, err
}
affected, _ := res.RowsAffected()
- s.log.Debug("rotated", "affected", affected, "auth_token_id", token.Id, "userId", token.UserId)
+ s.log.Debug("auth token rotated", "affected", affected, "auth_token_id", model.Id, "userId", model.UserId)
if affected > 0 {
- token.UnhashedToken = newToken
+ model.UnhashedToken = newToken
+ model.toUserToken(token)
return true, nil
}
return false, nil
}
+func (s *UserAuthTokenService) RevokeToken(token *models.UserToken) error {
+ if token == nil {
+ return models.ErrUserTokenNotFound
+ }
+
+ model := userAuthTokenFromUserToken(token)
+
+ rowsAffected, err := s.SQLStore.NewSession().Delete(model)
+ if err != nil {
+ return err
+ }
+
+ if rowsAffected == 0 {
+ s.log.Debug("user auth token not found/revoked", "tokenId", model.Id, "userId", model.UserId, "clientIP", model.ClientIp, "userAgent", model.UserAgent)
+ return models.ErrUserTokenNotFound
+ }
+
+ s.log.Debug("user auth token revoked", "tokenId", model.Id, "userId", model.UserId, "clientIP", model.ClientIp, "userAgent", model.UserAgent)
+
+ return nil
+}
+
func hashToken(token string) string {
hashBytes := sha256.Sum256([]byte(token + setting.SecretKey))
return hex.EncodeToString(hashBytes[:])
diff --git a/pkg/services/auth/auth_token_test.go b/pkg/services/auth/auth_token_test.go
index 312e53a3970..26dcbc5c868 100644
--- a/pkg/services/auth/auth_token_test.go
+++ b/pkg/services/auth/auth_token_test.go
@@ -1,17 +1,15 @@
package auth
import (
- "fmt"
- "net/http"
- "net/http/httptest"
+ "encoding/json"
"testing"
"time"
- "github.com/grafana/grafana/pkg/models"
+ "github.com/grafana/grafana/pkg/components/simplejson"
"github.com/grafana/grafana/pkg/setting"
- macaron "gopkg.in/macaron.v1"
"github.com/grafana/grafana/pkg/log"
+ "github.com/grafana/grafana/pkg/models"
"github.com/grafana/grafana/pkg/services/sqlstore"
. "github.com/smartystreets/goconvey/convey"
)
@@ -28,236 +26,265 @@ func TestUserAuthToken(t *testing.T) {
}
Convey("When creating token", func() {
- token, err := userAuthTokenService.CreateToken(userID, "192.168.10.11:1234", "some user agent")
+ userToken, err := userAuthTokenService.CreateToken(userID, "192.168.10.11:1234", "some user agent")
So(err, ShouldBeNil)
- So(token, ShouldNotBeNil)
- So(token.AuthTokenSeen, ShouldBeFalse)
+ So(userToken, ShouldNotBeNil)
+ So(userToken.AuthTokenSeen, ShouldBeFalse)
Convey("When lookup unhashed token should return user auth token", func() {
- LookupToken, err := userAuthTokenService.LookupToken(token.UnhashedToken)
+ userToken, err := userAuthTokenService.LookupToken(userToken.UnhashedToken)
So(err, ShouldBeNil)
- So(LookupToken, ShouldNotBeNil)
- So(LookupToken.UserId, ShouldEqual, userID)
- So(LookupToken.AuthTokenSeen, ShouldBeTrue)
+ So(userToken, ShouldNotBeNil)
+ So(userToken.UserId, ShouldEqual, userID)
+ So(userToken.AuthTokenSeen, ShouldBeTrue)
- storedAuthToken, err := ctx.getAuthTokenByID(LookupToken.Id)
+ storedAuthToken, err := ctx.getAuthTokenByID(userToken.Id)
So(err, ShouldBeNil)
So(storedAuthToken, ShouldNotBeNil)
So(storedAuthToken.AuthTokenSeen, ShouldBeTrue)
})
Convey("When lookup hashed token should return user auth token not found error", func() {
- LookupToken, err := userAuthTokenService.LookupToken(token.AuthToken)
- So(err, ShouldEqual, ErrAuthTokenNotFound)
- So(LookupToken, ShouldBeNil)
+ userToken, err := userAuthTokenService.LookupToken(userToken.AuthToken)
+ So(err, ShouldEqual, models.ErrUserTokenNotFound)
+ So(userToken, ShouldBeNil)
})
- Convey("signing out should delete token and cookie if present", func() {
- httpreq := &http.Request{Header: make(http.Header)}
- httpreq.AddCookie(&http.Cookie{Name: userAuthTokenService.Cfg.LoginCookieName, Value: token.UnhashedToken})
-
- ctx := &models.ReqContext{Context: &macaron.Context{
- Req: macaron.Request{Request: httpreq},
- Resp: macaron.NewResponseWriter("POST", httptest.NewRecorder()),
- },
- Logger: log.New("fakelogger"),
- }
-
- err = userAuthTokenService.SignOutUser(ctx)
+ Convey("revoking existing token should delete token", func() {
+ err = userAuthTokenService.RevokeToken(userToken)
So(err, ShouldBeNil)
- // makes sure we tell the browser to overwrite the cookie
- cookieHeader := fmt.Sprintf("%s=; Path=/; Max-Age=0; HttpOnly", userAuthTokenService.Cfg.LoginCookieName)
- So(ctx.Resp.Header().Get("Set-Cookie"), ShouldEqual, cookieHeader)
+ model, err := ctx.getAuthTokenByID(userToken.Id)
+ So(err, ShouldBeNil)
+ So(model, ShouldBeNil)
})
- Convey("signing out an none existing session should return an error", func() {
- httpreq := &http.Request{Header: make(http.Header)}
- httpreq.AddCookie(&http.Cookie{Name: userAuthTokenService.Cfg.LoginCookieName, Value: ""})
+ Convey("revoking nil token should return error", func() {
+ err = userAuthTokenService.RevokeToken(nil)
+ So(err, ShouldEqual, models.ErrUserTokenNotFound)
+ })
- ctx := &models.ReqContext{Context: &macaron.Context{
- Req: macaron.Request{Request: httpreq},
- Resp: macaron.NewResponseWriter("POST", httptest.NewRecorder()),
- },
- Logger: log.New("fakelogger"),
- }
-
- err = userAuthTokenService.SignOutUser(ctx)
- So(err, ShouldNotBeNil)
+ Convey("revoking non-existing token should return error", func() {
+ userToken.Id = 1000
+ err = userAuthTokenService.RevokeToken(userToken)
+ So(err, ShouldEqual, models.ErrUserTokenNotFound)
})
})
Convey("expires correctly", func() {
- token, err := userAuthTokenService.CreateToken(userID, "192.168.10.11:1234", "some user agent")
- So(err, ShouldBeNil)
- So(token, ShouldNotBeNil)
-
- _, err = userAuthTokenService.LookupToken(token.UnhashedToken)
+ userToken, err := userAuthTokenService.CreateToken(userID, "192.168.10.11:1234", "some user agent")
So(err, ShouldBeNil)
- token, err = ctx.getAuthTokenByID(token.Id)
+ userToken, err = userAuthTokenService.LookupToken(userToken.UnhashedToken)
So(err, ShouldBeNil)
getTime = func() time.Time {
return t.Add(time.Hour)
}
- refreshed, err := userAuthTokenService.RefreshToken(token, "192.168.10.11:1234", "some user agent")
+ rotated, err := userAuthTokenService.TryRotateToken(userToken, "192.168.10.11:1234", "some user agent")
So(err, ShouldBeNil)
- So(refreshed, ShouldBeTrue)
+ So(rotated, ShouldBeTrue)
- _, err = userAuthTokenService.LookupToken(token.UnhashedToken)
+ userToken, err = userAuthTokenService.LookupToken(userToken.UnhashedToken)
So(err, ShouldBeNil)
- stillGood, err := userAuthTokenService.LookupToken(token.UnhashedToken)
+ stillGood, err := userAuthTokenService.LookupToken(userToken.UnhashedToken)
So(err, ShouldBeNil)
So(stillGood, ShouldNotBeNil)
- getTime = func() time.Time {
- return t.Add(24 * 7 * time.Hour)
- }
- notGood, err := userAuthTokenService.LookupToken(token.UnhashedToken)
- So(err, ShouldEqual, ErrAuthTokenNotFound)
- So(notGood, ShouldBeNil)
+ model, err := ctx.getAuthTokenByID(userToken.Id)
+ So(err, ShouldBeNil)
+
+ Convey("when rotated_at is 6:59:59 ago should find token", func() {
+ getTime = func() time.Time {
+ return time.Unix(model.RotatedAt, 0).Add(24 * 7 * time.Hour).Add(-time.Second)
+ }
+
+ stillGood, err = userAuthTokenService.LookupToken(stillGood.UnhashedToken)
+ So(err, ShouldBeNil)
+ So(stillGood, ShouldNotBeNil)
+ })
+
+ Convey("when rotated_at is 7:00:00 ago should not find token", func() {
+ getTime = func() time.Time {
+ return time.Unix(model.RotatedAt, 0).Add(24 * 7 * time.Hour)
+ }
+
+ notGood, err := userAuthTokenService.LookupToken(userToken.UnhashedToken)
+ So(err, ShouldEqual, models.ErrUserTokenNotFound)
+ So(notGood, ShouldBeNil)
+ })
+
+ Convey("when rotated_at is 5 days ago and created_at is 29 days and 23:59:59 ago should not find token", func() {
+ updated, err := ctx.updateRotatedAt(model.Id, time.Unix(model.CreatedAt, 0).Add(24*25*time.Hour).Unix())
+ So(err, ShouldBeNil)
+ So(updated, ShouldBeTrue)
+
+ getTime = func() time.Time {
+ return time.Unix(model.CreatedAt, 0).Add(24 * 30 * time.Hour).Add(-time.Second)
+ }
+
+ stillGood, err = userAuthTokenService.LookupToken(stillGood.UnhashedToken)
+ So(err, ShouldBeNil)
+ So(stillGood, ShouldNotBeNil)
+ })
+
+ Convey("when rotated_at is 5 days ago and created_at is 30 days ago should not find token", func() {
+ updated, err := ctx.updateRotatedAt(model.Id, time.Unix(model.CreatedAt, 0).Add(24*25*time.Hour).Unix())
+ So(err, ShouldBeNil)
+ So(updated, ShouldBeTrue)
+
+ getTime = func() time.Time {
+ return time.Unix(model.CreatedAt, 0).Add(24 * 30 * time.Hour)
+ }
+
+ notGood, err := userAuthTokenService.LookupToken(userToken.UnhashedToken)
+ So(err, ShouldEqual, models.ErrUserTokenNotFound)
+ So(notGood, ShouldBeNil)
+ })
})
Convey("can properly rotate tokens", func() {
- token, err := userAuthTokenService.CreateToken(userID, "192.168.10.11:1234", "some user agent")
+ userToken, err := userAuthTokenService.CreateToken(userID, "192.168.10.11:1234", "some user agent")
So(err, ShouldBeNil)
- So(token, ShouldNotBeNil)
- prevToken := token.AuthToken
- unhashedPrev := token.UnhashedToken
+ prevToken := userToken.AuthToken
+ unhashedPrev := userToken.UnhashedToken
- refreshed, err := userAuthTokenService.RefreshToken(token, "192.168.10.12:1234", "a new user agent")
+ rotated, err := userAuthTokenService.TryRotateToken(userToken, "192.168.10.12:1234", "a new user agent")
So(err, ShouldBeNil)
- So(refreshed, ShouldBeFalse)
+ So(rotated, ShouldBeFalse)
- updated, err := ctx.markAuthTokenAsSeen(token.Id)
+ updated, err := ctx.markAuthTokenAsSeen(userToken.Id)
So(err, ShouldBeNil)
So(updated, ShouldBeTrue)
- token, err = ctx.getAuthTokenByID(token.Id)
+ model, err := ctx.getAuthTokenByID(userToken.Id)
+ So(err, ShouldBeNil)
+
+ var tok models.UserToken
+ err = model.toUserToken(&tok)
So(err, ShouldBeNil)
getTime = func() time.Time {
return t.Add(time.Hour)
}
- refreshed, err = userAuthTokenService.RefreshToken(token, "192.168.10.12:1234", "a new user agent")
+ rotated, err = userAuthTokenService.TryRotateToken(&tok, "192.168.10.12:1234", "a new user agent")
So(err, ShouldBeNil)
- So(refreshed, ShouldBeTrue)
+ So(rotated, ShouldBeTrue)
- unhashedToken := token.UnhashedToken
+ unhashedToken := tok.UnhashedToken
- token, err = ctx.getAuthTokenByID(token.Id)
+ model, err = ctx.getAuthTokenByID(tok.Id)
So(err, ShouldBeNil)
- token.UnhashedToken = unhashedToken
+ model.UnhashedToken = unhashedToken
- So(token.RotatedAt, ShouldEqual, getTime().Unix())
- So(token.ClientIp, ShouldEqual, "192.168.10.12")
- So(token.UserAgent, ShouldEqual, "a new user agent")
- So(token.AuthTokenSeen, ShouldBeFalse)
- So(token.SeenAt, ShouldEqual, 0)
- So(token.PrevAuthToken, ShouldEqual, prevToken)
+ So(model.RotatedAt, ShouldEqual, getTime().Unix())
+ So(model.ClientIp, ShouldEqual, "192.168.10.12")
+ So(model.UserAgent, ShouldEqual, "a new user agent")
+ So(model.AuthTokenSeen, ShouldBeFalse)
+ So(model.SeenAt, ShouldEqual, 0)
+ So(model.PrevAuthToken, ShouldEqual, prevToken)
// ability to auth using an old token
- lookedUp, err := userAuthTokenService.LookupToken(token.UnhashedToken)
+ lookedUpUserToken, err := userAuthTokenService.LookupToken(model.UnhashedToken)
So(err, ShouldBeNil)
- So(lookedUp, ShouldNotBeNil)
- So(lookedUp.AuthTokenSeen, ShouldBeTrue)
- So(lookedUp.SeenAt, ShouldEqual, getTime().Unix())
+ So(lookedUpUserToken, ShouldNotBeNil)
+ So(lookedUpUserToken.AuthTokenSeen, ShouldBeTrue)
+ So(lookedUpUserToken.SeenAt, ShouldEqual, getTime().Unix())
- lookedUp, err = userAuthTokenService.LookupToken(unhashedPrev)
+ lookedUpUserToken, err = userAuthTokenService.LookupToken(unhashedPrev)
So(err, ShouldBeNil)
- So(lookedUp, ShouldNotBeNil)
- So(lookedUp.Id, ShouldEqual, token.Id)
- So(lookedUp.AuthTokenSeen, ShouldBeTrue)
+ So(lookedUpUserToken, ShouldNotBeNil)
+ So(lookedUpUserToken.Id, ShouldEqual, model.Id)
+ So(lookedUpUserToken.AuthTokenSeen, ShouldBeTrue)
getTime = func() time.Time {
return t.Add(time.Hour + (2 * time.Minute))
}
- lookedUp, err = userAuthTokenService.LookupToken(unhashedPrev)
+ lookedUpUserToken, err = userAuthTokenService.LookupToken(unhashedPrev)
So(err, ShouldBeNil)
- So(lookedUp, ShouldNotBeNil)
- So(lookedUp.AuthTokenSeen, ShouldBeTrue)
+ So(lookedUpUserToken, ShouldNotBeNil)
+ So(lookedUpUserToken.AuthTokenSeen, ShouldBeTrue)
- lookedUp, err = ctx.getAuthTokenByID(lookedUp.Id)
+ lookedUpModel, err := ctx.getAuthTokenByID(lookedUpUserToken.Id)
So(err, ShouldBeNil)
- So(lookedUp, ShouldNotBeNil)
- So(lookedUp.AuthTokenSeen, ShouldBeFalse)
+ So(lookedUpModel, ShouldNotBeNil)
+ So(lookedUpModel.AuthTokenSeen, ShouldBeFalse)
- refreshed, err = userAuthTokenService.RefreshToken(token, "192.168.10.12:1234", "a new user agent")
+ rotated, err = userAuthTokenService.TryRotateToken(userToken, "192.168.10.12:1234", "a new user agent")
So(err, ShouldBeNil)
- So(refreshed, ShouldBeTrue)
+ So(rotated, ShouldBeTrue)
- token, err = ctx.getAuthTokenByID(token.Id)
+ model, err = ctx.getAuthTokenByID(userToken.Id)
So(err, ShouldBeNil)
- So(token, ShouldNotBeNil)
- So(token.SeenAt, ShouldEqual, 0)
+ So(model, ShouldNotBeNil)
+ So(model.SeenAt, ShouldEqual, 0)
})
Convey("keeps prev token valid for 1 minute after it is confirmed", func() {
- token, err := userAuthTokenService.CreateToken(userID, "192.168.10.11:1234", "some user agent")
+ userToken, err := userAuthTokenService.CreateToken(userID, "192.168.10.11:1234", "some user agent")
So(err, ShouldBeNil)
- So(token, ShouldNotBeNil)
+ So(userToken, ShouldNotBeNil)
- lookedUp, err := userAuthTokenService.LookupToken(token.UnhashedToken)
+ lookedUpUserToken, err := userAuthTokenService.LookupToken(userToken.UnhashedToken)
So(err, ShouldBeNil)
- So(lookedUp, ShouldNotBeNil)
+ So(lookedUpUserToken, ShouldNotBeNil)
getTime = func() time.Time {
return t.Add(10 * time.Minute)
}
- prevToken := token.UnhashedToken
- refreshed, err := userAuthTokenService.RefreshToken(token, "1.1.1.1", "firefox")
+ prevToken := userToken.UnhashedToken
+ rotated, err := userAuthTokenService.TryRotateToken(userToken, "1.1.1.1", "firefox")
So(err, ShouldBeNil)
- So(refreshed, ShouldBeTrue)
+ So(rotated, ShouldBeTrue)
getTime = func() time.Time {
return t.Add(20 * time.Minute)
}
- current, err := userAuthTokenService.LookupToken(token.UnhashedToken)
+ currentUserToken, err := userAuthTokenService.LookupToken(userToken.UnhashedToken)
So(err, ShouldBeNil)
- So(current, ShouldNotBeNil)
+ So(currentUserToken, ShouldNotBeNil)
- prev, err := userAuthTokenService.LookupToken(prevToken)
+ prevUserToken, err := userAuthTokenService.LookupToken(prevToken)
So(err, ShouldBeNil)
- So(prev, ShouldNotBeNil)
+ So(prevUserToken, ShouldNotBeNil)
})
Convey("will not mark token unseen when prev and current are the same", func() {
- token, err := userAuthTokenService.CreateToken(userID, "192.168.10.11:1234", "some user agent")
+ userToken, err := userAuthTokenService.CreateToken(userID, "192.168.10.11:1234", "some user agent")
So(err, ShouldBeNil)
- So(token, ShouldNotBeNil)
+ So(userToken, ShouldNotBeNil)
- lookedUp, err := userAuthTokenService.LookupToken(token.UnhashedToken)
+ lookedUpUserToken, err := userAuthTokenService.LookupToken(userToken.UnhashedToken)
So(err, ShouldBeNil)
- So(lookedUp, ShouldNotBeNil)
+ So(lookedUpUserToken, ShouldNotBeNil)
- lookedUp, err = userAuthTokenService.LookupToken(token.UnhashedToken)
+ lookedUpUserToken, err = userAuthTokenService.LookupToken(userToken.UnhashedToken)
So(err, ShouldBeNil)
- So(lookedUp, ShouldNotBeNil)
+ So(lookedUpUserToken, ShouldNotBeNil)
- lookedUp, err = ctx.getAuthTokenByID(lookedUp.Id)
+ lookedUpModel, err := ctx.getAuthTokenByID(lookedUpUserToken.Id)
So(err, ShouldBeNil)
- So(lookedUp, ShouldNotBeNil)
- So(lookedUp.AuthTokenSeen, ShouldBeTrue)
+ So(lookedUpModel, ShouldNotBeNil)
+ So(lookedUpModel.AuthTokenSeen, ShouldBeTrue)
})
Convey("Rotate token", func() {
- token, err := userAuthTokenService.CreateToken(userID, "192.168.10.11:1234", "some user agent")
+ userToken, err := userAuthTokenService.CreateToken(userID, "192.168.10.11:1234", "some user agent")
So(err, ShouldBeNil)
- So(token, ShouldNotBeNil)
+ So(userToken, ShouldNotBeNil)
- prevToken := token.AuthToken
+ prevToken := userToken.AuthToken
Convey("Should rotate current token and previous token when auth token seen", func() {
- updated, err := ctx.markAuthTokenAsSeen(token.Id)
+ updated, err := ctx.markAuthTokenAsSeen(userToken.Id)
So(err, ShouldBeNil)
So(updated, ShouldBeTrue)
@@ -265,11 +292,11 @@ func TestUserAuthToken(t *testing.T) {
return t.Add(10 * time.Minute)
}
- refreshed, err := userAuthTokenService.RefreshToken(token, "1.1.1.1", "firefox")
+ rotated, err := userAuthTokenService.TryRotateToken(userToken, "1.1.1.1", "firefox")
So(err, ShouldBeNil)
- So(refreshed, ShouldBeTrue)
+ So(rotated, ShouldBeTrue)
- storedToken, err := ctx.getAuthTokenByID(token.Id)
+ storedToken, err := ctx.getAuthTokenByID(userToken.Id)
So(err, ShouldBeNil)
So(storedToken, ShouldNotBeNil)
So(storedToken.AuthTokenSeen, ShouldBeFalse)
@@ -278,7 +305,7 @@ func TestUserAuthToken(t *testing.T) {
prevToken = storedToken.AuthToken
- updated, err = ctx.markAuthTokenAsSeen(token.Id)
+ updated, err = ctx.markAuthTokenAsSeen(userToken.Id)
So(err, ShouldBeNil)
So(updated, ShouldBeTrue)
@@ -286,11 +313,11 @@ func TestUserAuthToken(t *testing.T) {
return t.Add(20 * time.Minute)
}
- refreshed, err = userAuthTokenService.RefreshToken(token, "1.1.1.1", "firefox")
+ rotated, err = userAuthTokenService.TryRotateToken(userToken, "1.1.1.1", "firefox")
So(err, ShouldBeNil)
- So(refreshed, ShouldBeTrue)
+ So(rotated, ShouldBeTrue)
- storedToken, err = ctx.getAuthTokenByID(token.Id)
+ storedToken, err = ctx.getAuthTokenByID(userToken.Id)
So(err, ShouldBeNil)
So(storedToken, ShouldNotBeNil)
So(storedToken.AuthTokenSeen, ShouldBeFalse)
@@ -299,17 +326,17 @@ func TestUserAuthToken(t *testing.T) {
})
Convey("Should rotate current token, but keep previous token when auth token not seen", func() {
- token.RotatedAt = getTime().Add(-2 * time.Minute).Unix()
+ userToken.RotatedAt = getTime().Add(-2 * time.Minute).Unix()
getTime = func() time.Time {
return t.Add(2 * time.Minute)
}
- refreshed, err := userAuthTokenService.RefreshToken(token, "1.1.1.1", "firefox")
+ rotated, err := userAuthTokenService.TryRotateToken(userToken, "1.1.1.1", "firefox")
So(err, ShouldBeNil)
- So(refreshed, ShouldBeTrue)
+ So(rotated, ShouldBeTrue)
- storedToken, err := ctx.getAuthTokenByID(token.Id)
+ storedToken, err := ctx.getAuthTokenByID(userToken.Id)
So(err, ShouldBeNil)
So(storedToken, ShouldNotBeNil)
So(storedToken.AuthTokenSeen, ShouldBeFalse)
@@ -318,6 +345,71 @@ func TestUserAuthToken(t *testing.T) {
})
})
+ Convey("When populating userAuthToken from UserToken should copy all properties", func() {
+ ut := models.UserToken{
+ Id: 1,
+ UserId: 2,
+ AuthToken: "a",
+ PrevAuthToken: "b",
+ UserAgent: "c",
+ ClientIp: "d",
+ AuthTokenSeen: true,
+ SeenAt: 3,
+ RotatedAt: 4,
+ CreatedAt: 5,
+ UpdatedAt: 6,
+ UnhashedToken: "e",
+ }
+ utBytes, err := json.Marshal(ut)
+ So(err, ShouldBeNil)
+ utJSON, err := simplejson.NewJson(utBytes)
+ So(err, ShouldBeNil)
+ utMap := utJSON.MustMap()
+
+ var uat userAuthToken
+ uat.fromUserToken(&ut)
+ uatBytes, err := json.Marshal(uat)
+ So(err, ShouldBeNil)
+ uatJSON, err := simplejson.NewJson(uatBytes)
+ So(err, ShouldBeNil)
+ uatMap := uatJSON.MustMap()
+
+ So(uatMap, ShouldResemble, utMap)
+ })
+
+ Convey("When populating userToken from userAuthToken should copy all properties", func() {
+ uat := userAuthToken{
+ Id: 1,
+ UserId: 2,
+ AuthToken: "a",
+ PrevAuthToken: "b",
+ UserAgent: "c",
+ ClientIp: "d",
+ AuthTokenSeen: true,
+ SeenAt: 3,
+ RotatedAt: 4,
+ CreatedAt: 5,
+ UpdatedAt: 6,
+ UnhashedToken: "e",
+ }
+ uatBytes, err := json.Marshal(uat)
+ So(err, ShouldBeNil)
+ uatJSON, err := simplejson.NewJson(uatBytes)
+ So(err, ShouldBeNil)
+ uatMap := uatJSON.MustMap()
+
+ var ut models.UserToken
+ err = uat.toUserToken(&ut)
+ So(err, ShouldBeNil)
+ utBytes, err := json.Marshal(ut)
+ So(err, ShouldBeNil)
+ utJSON, err := simplejson.NewJson(utBytes)
+ So(err, ShouldBeNil)
+ utMap := utJSON.MustMap()
+
+ So(utMap, ShouldResemble, uatMap)
+ })
+
Reset(func() {
getTime = time.Now
})
@@ -328,19 +420,16 @@ func createTestContext(t *testing.T) *testContext {
t.Helper()
sqlstore := sqlstore.InitTestDB(t)
- tokenService := &UserAuthTokenServiceImpl{
+ tokenService := &UserAuthTokenService{
SQLStore: sqlstore,
Cfg: &setting.Cfg{
- LoginCookieName: "grafana_session",
- LoginCookieMaxDays: 7,
- LoginDeleteExpiredTokensAfterDays: 30,
- LoginCookieRotation: 10,
+ LoginMaxInactiveLifetimeDays: 7,
+ LoginMaxLifetimeDays: 30,
+ TokenRotationIntervalMinutes: 10,
},
log: log.New("test-logger"),
}
- UrgentRotateTime = time.Minute
-
return &testContext{
sqlstore: sqlstore,
tokenService: tokenService,
@@ -349,7 +438,7 @@ func createTestContext(t *testing.T) *testContext {
type testContext struct {
sqlstore *sqlstore.SqlStore
- tokenService *UserAuthTokenServiceImpl
+ tokenService *UserAuthTokenService
}
func (c *testContext) getAuthTokenByID(id int64) (*userAuthToken, error) {
@@ -376,3 +465,17 @@ func (c *testContext) markAuthTokenAsSeen(id int64) (bool, error) {
}
return rowsAffected == 1, nil
}
+
+func (c *testContext) updateRotatedAt(id, rotatedAt int64) (bool, error) {
+ sess := c.sqlstore.NewSession()
+ res, err := sess.Exec("UPDATE user_auth_token SET rotated_at = ? WHERE id = ?", rotatedAt, id)
+ if err != nil {
+ return false, err
+ }
+
+ rowsAffected, err := res.RowsAffected()
+ if err != nil {
+ return false, err
+ }
+ return rowsAffected == 1, nil
+}
diff --git a/pkg/services/auth/model.go b/pkg/services/auth/model.go
index 7a0f49539f2..36652e70436 100644
--- a/pkg/services/auth/model.go
+++ b/pkg/services/auth/model.go
@@ -1,12 +1,9 @@
package auth
import (
- "errors"
-)
+ "fmt"
-// Typed errors
-var (
- ErrAuthTokenNotFound = errors.New("User auth token not found")
+ "github.com/grafana/grafana/pkg/models"
)
type userAuthToken struct {
@@ -23,3 +20,51 @@ type userAuthToken struct {
UpdatedAt int64
UnhashedToken string `xorm:"-"`
}
+
+func userAuthTokenFromUserToken(ut *models.UserToken) *userAuthToken {
+ var uat userAuthToken
+ uat.fromUserToken(ut)
+ return &uat
+}
+
+func (uat *userAuthToken) fromUserToken(ut *models.UserToken) error {
+ if uat == nil {
+ return fmt.Errorf("needs pointer to userAuthToken struct")
+ }
+
+ uat.Id = ut.Id
+ uat.UserId = ut.UserId
+ uat.AuthToken = ut.AuthToken
+ uat.PrevAuthToken = ut.PrevAuthToken
+ uat.UserAgent = ut.UserAgent
+ uat.ClientIp = ut.ClientIp
+ uat.AuthTokenSeen = ut.AuthTokenSeen
+ uat.SeenAt = ut.SeenAt
+ uat.RotatedAt = ut.RotatedAt
+ uat.CreatedAt = ut.CreatedAt
+ uat.UpdatedAt = ut.UpdatedAt
+ uat.UnhashedToken = ut.UnhashedToken
+
+ return nil
+}
+
+func (uat *userAuthToken) toUserToken(ut *models.UserToken) error {
+ if uat == nil {
+ return fmt.Errorf("needs pointer to userAuthToken struct")
+ }
+
+ ut.Id = uat.Id
+ ut.UserId = uat.UserId
+ ut.AuthToken = uat.AuthToken
+ ut.PrevAuthToken = uat.PrevAuthToken
+ ut.UserAgent = uat.UserAgent
+ ut.ClientIp = uat.ClientIp
+ ut.AuthTokenSeen = uat.AuthTokenSeen
+ ut.SeenAt = uat.SeenAt
+ ut.RotatedAt = uat.RotatedAt
+ ut.CreatedAt = uat.CreatedAt
+ ut.UpdatedAt = uat.UpdatedAt
+ ut.UnhashedToken = uat.UnhashedToken
+
+ return nil
+}
diff --git a/pkg/services/auth/session_cleanup.go b/pkg/services/auth/session_cleanup.go
deleted file mode 100644
index 7e523181a7b..00000000000
--- a/pkg/services/auth/session_cleanup.go
+++ /dev/null
@@ -1,38 +0,0 @@
-package auth
-
-import (
- "context"
- "time"
-)
-
-func (srv *UserAuthTokenServiceImpl) Run(ctx context.Context) error {
- ticker := time.NewTicker(time.Hour * 12)
- deleteSessionAfter := time.Hour * 24 * time.Duration(srv.Cfg.LoginDeleteExpiredTokensAfterDays)
-
- for {
- select {
- case <-ticker.C:
- srv.ServerLockService.LockAndExecute(ctx, "delete old sessions", time.Hour*12, func() {
- srv.deleteOldSession(deleteSessionAfter)
- })
-
- case <-ctx.Done():
- return ctx.Err()
- }
- }
-}
-
-func (srv *UserAuthTokenServiceImpl) deleteOldSession(deleteSessionAfter time.Duration) (int64, error) {
- sql := `DELETE from user_auth_token WHERE rotated_at < ?`
-
- deleteBefore := getTime().Add(-deleteSessionAfter)
- res, err := srv.SQLStore.NewSession().Exec(sql, deleteBefore.Unix())
- if err != nil {
- return 0, err
- }
-
- affected, err := res.RowsAffected()
- srv.log.Info("deleted old sessions", "count", affected)
-
- return affected, err
-}
diff --git a/pkg/services/auth/session_cleanup_test.go b/pkg/services/auth/session_cleanup_test.go
deleted file mode 100644
index eef2cd74d04..00000000000
--- a/pkg/services/auth/session_cleanup_test.go
+++ /dev/null
@@ -1,36 +0,0 @@
-package auth
-
-import (
- "fmt"
- "testing"
- "time"
-
- . "github.com/smartystreets/goconvey/convey"
-)
-
-func TestUserAuthTokenCleanup(t *testing.T) {
-
- Convey("Test user auth token cleanup", t, func() {
- ctx := createTestContext(t)
-
- insertToken := func(token string, prev string, rotatedAt int64) {
- ut := userAuthToken{AuthToken: token, PrevAuthToken: prev, RotatedAt: rotatedAt, UserAgent: "", ClientIp: ""}
- _, err := ctx.sqlstore.NewSession().Insert(&ut)
- So(err, ShouldBeNil)
- }
-
- // insert three old tokens that should be deleted
- for i := 0; i < 3; i++ {
- insertToken(fmt.Sprintf("oldA%d", i), fmt.Sprintf("oldB%d", i), int64(i))
- }
-
- // insert three active tokens that should not be deleted
- for i := 0; i < 3; i++ {
- insertToken(fmt.Sprintf("newA%d", i), fmt.Sprintf("newB%d", i), getTime().Unix())
- }
-
- affected, err := ctx.tokenService.deleteOldSession(time.Hour)
- So(err, ShouldBeNil)
- So(affected, ShouldEqual, 3)
- })
-}
diff --git a/pkg/services/auth/token_cleanup.go b/pkg/services/auth/token_cleanup.go
new file mode 100644
index 00000000000..aa5bc4856ab
--- /dev/null
+++ b/pkg/services/auth/token_cleanup.go
@@ -0,0 +1,57 @@
+package auth
+
+import (
+ "context"
+ "time"
+)
+
+func (srv *UserAuthTokenService) Run(ctx context.Context) error {
+ ticker := time.NewTicker(time.Hour)
+ maxInactiveLifetime := time.Duration(srv.Cfg.LoginMaxInactiveLifetimeDays) * 24 * time.Hour
+ maxLifetime := time.Duration(srv.Cfg.LoginMaxLifetimeDays) * 24 * time.Hour
+
+ err := srv.ServerLockService.LockAndExecute(ctx, "cleanup expired auth tokens", time.Hour*12, func() {
+ srv.deleteExpiredTokens(maxInactiveLifetime, maxLifetime)
+ })
+ if err != nil {
+ srv.log.Error("failed to lock and execite cleanup of expired auth token", "erro", err)
+ }
+
+ for {
+ select {
+ case <-ticker.C:
+ err := srv.ServerLockService.LockAndExecute(ctx, "cleanup expired auth tokens", time.Hour*12, func() {
+ srv.deleteExpiredTokens(maxInactiveLifetime, maxLifetime)
+ })
+
+ if err != nil {
+ srv.log.Error("failed to lock and execite cleanup of expired auth token", "erro", err)
+ }
+
+ case <-ctx.Done():
+ return ctx.Err()
+ }
+ }
+}
+
+func (srv *UserAuthTokenService) deleteExpiredTokens(maxInactiveLifetime, maxLifetime time.Duration) (int64, error) {
+ createdBefore := getTime().Add(-maxLifetime)
+ rotatedBefore := getTime().Add(-maxInactiveLifetime)
+
+ srv.log.Debug("starting cleanup of expired auth tokens", "createdBefore", createdBefore, "rotatedBefore", rotatedBefore)
+
+ sql := `DELETE from user_auth_token WHERE created_at <= ? OR rotated_at <= ?`
+ res, err := srv.SQLStore.NewSession().Exec(sql, createdBefore.Unix(), rotatedBefore.Unix())
+ if err != nil {
+ return 0, err
+ }
+
+ affected, err := res.RowsAffected()
+ if err != nil {
+ srv.log.Error("failed to cleanup expired auth tokens", "error", err)
+ return 0, nil
+ }
+
+ srv.log.Info("cleanup of expired auth tokens done", "count", affected)
+ return affected, err
+}
diff --git a/pkg/services/auth/token_cleanup_test.go b/pkg/services/auth/token_cleanup_test.go
new file mode 100644
index 00000000000..410764d3f8d
--- /dev/null
+++ b/pkg/services/auth/token_cleanup_test.go
@@ -0,0 +1,68 @@
+package auth
+
+import (
+ "fmt"
+ "testing"
+ "time"
+
+ . "github.com/smartystreets/goconvey/convey"
+)
+
+func TestUserAuthTokenCleanup(t *testing.T) {
+
+ Convey("Test user auth token cleanup", t, func() {
+ ctx := createTestContext(t)
+ ctx.tokenService.Cfg.LoginMaxInactiveLifetimeDays = 7
+ ctx.tokenService.Cfg.LoginMaxLifetimeDays = 30
+
+ insertToken := func(token string, prev string, createdAt, rotatedAt int64) {
+ ut := userAuthToken{AuthToken: token, PrevAuthToken: prev, CreatedAt: createdAt, RotatedAt: rotatedAt, UserAgent: "", ClientIp: ""}
+ _, err := ctx.sqlstore.NewSession().Insert(&ut)
+ So(err, ShouldBeNil)
+ }
+
+ t := time.Date(2018, 12, 13, 13, 45, 0, 0, time.UTC)
+ getTime = func() time.Time {
+ return t
+ }
+
+ Convey("should delete tokens where token rotation age is older than or equal 7 days", func() {
+ from := t.Add(-7 * 24 * time.Hour)
+
+ // insert three old tokens that should be deleted
+ for i := 0; i < 3; i++ {
+ insertToken(fmt.Sprintf("oldA%d", i), fmt.Sprintf("oldB%d", i), from.Unix(), from.Unix())
+ }
+
+ // insert three active tokens that should not be deleted
+ for i := 0; i < 3; i++ {
+ from = from.Add(time.Second)
+ insertToken(fmt.Sprintf("newA%d", i), fmt.Sprintf("newB%d", i), from.Unix(), from.Unix())
+ }
+
+ affected, err := ctx.tokenService.deleteExpiredTokens(7*24*time.Hour, 30*24*time.Hour)
+ So(err, ShouldBeNil)
+ So(affected, ShouldEqual, 3)
+ })
+
+ Convey("should delete tokens where token age is older than or equal 30 days", func() {
+ from := t.Add(-30 * 24 * time.Hour)
+ fromRotate := t.Add(-time.Second)
+
+ // insert three old tokens that should be deleted
+ for i := 0; i < 3; i++ {
+ insertToken(fmt.Sprintf("oldA%d", i), fmt.Sprintf("oldB%d", i), from.Unix(), fromRotate.Unix())
+ }
+
+ // insert three active tokens that should not be deleted
+ for i := 0; i < 3; i++ {
+ from = from.Add(time.Second)
+ insertToken(fmt.Sprintf("newA%d", i), fmt.Sprintf("newB%d", i), from.Unix(), fromRotate.Unix())
+ }
+
+ affected, err := ctx.tokenService.deleteExpiredTokens(7*24*time.Hour, 30*24*time.Hour)
+ So(err, ShouldBeNil)
+ So(affected, ShouldEqual, 3)
+ })
+ })
+}
diff --git a/pkg/services/provisioning/dashboards/config_reader.go b/pkg/services/provisioning/dashboards/config_reader.go
index fa08972961d..c57ca1c55e1 100644
--- a/pkg/services/provisioning/dashboards/config_reader.go
+++ b/pkg/services/provisioning/dashboards/config_reader.go
@@ -59,7 +59,7 @@ func (cr *configReader) readConfig() ([]*DashboardsAsConfig, error) {
files, err := ioutil.ReadDir(cr.path)
if err != nil {
- cr.log.Error("can't read dashboard provisioning files from directory", "path", cr.path)
+ cr.log.Error("can't read dashboard provisioning files from directory", "path", cr.path, "error", err)
return dashboards, nil
}
diff --git a/pkg/services/provisioning/datasources/config_reader.go b/pkg/services/provisioning/datasources/config_reader.go
index b2930c2b679..34c1418aa98 100644
--- a/pkg/services/provisioning/datasources/config_reader.go
+++ b/pkg/services/provisioning/datasources/config_reader.go
@@ -19,7 +19,7 @@ func (cr *configReader) readConfig(path string) ([]*DatasourcesAsConfig, error)
files, err := ioutil.ReadDir(path)
if err != nil {
- cr.log.Error("can't read datasource provisioning files from directory", "path", path)
+ cr.log.Error("can't read datasource provisioning files from directory", "path", path, "error", err)
return datasources, nil
}
diff --git a/pkg/services/provisioning/notifiers/config_reader.go b/pkg/services/provisioning/notifiers/config_reader.go
index e712e8e3eff..c1b4cbf9f29 100644
--- a/pkg/services/provisioning/notifiers/config_reader.go
+++ b/pkg/services/provisioning/notifiers/config_reader.go
@@ -23,7 +23,7 @@ func (cr *configReader) readConfig(path string) ([]*notificationsAsConfig, error
files, err := ioutil.ReadDir(path)
if err != nil {
- cr.log.Error("Can't read alert notification provisioning files from directory", "path", path)
+ cr.log.Error("Can't read alert notification provisioning files from directory", "path", path, "error", err)
return notifications, nil
}
diff --git a/pkg/services/sqlstore/stats.go b/pkg/services/sqlstore/stats.go
index 2cec86e7239..2b7c35a4b4a 100644
--- a/pkg/services/sqlstore/stats.go
+++ b/pkg/services/sqlstore/stats.go
@@ -74,7 +74,8 @@ func GetSystemStats(query *m.GetSystemStatsQuery) error {
sb.Write(`(SELECT COUNT(id) FROM ` + dialect.Quote("dashboard_provisioning") + `) AS provisioned_dashboards,`)
sb.Write(`(SELECT COUNT(id) FROM ` + dialect.Quote("dashboard_snapshot") + `) AS snapshots,`)
- sb.Write(`(SELECT COUNT(id) FROM ` + dialect.Quote("team") + `) AS teams`)
+ sb.Write(`(SELECT COUNT(id) FROM ` + dialect.Quote("team") + `) AS teams,`)
+ sb.Write(`(SELECT COUNT(id) FROM ` + dialect.Quote("user_auth_token") + `) AS auth_tokens`)
var stats m.SystemStats
_, err := x.SQL(sb.GetSqlString(), sb.params...).Get(&stats)
diff --git a/pkg/setting/setting.go b/pkg/setting/setting.go
index c3c78d10fec..21899482529 100644
--- a/pkg/setting/setting.go
+++ b/pkg/setting/setting.go
@@ -89,6 +89,8 @@ var (
EmailCodeValidMinutes int
DataProxyWhiteList map[string]bool
DisableBruteForceLoginProtection bool
+ CookieSecure bool
+ CookieSameSite http.SameSite
// Snapshots
ExternalSnapshotUrl string
@@ -118,8 +120,10 @@ var (
ViewersCanEdit bool
// Http auth
- AdminUser string
- AdminPassword string
+ AdminUser string
+ AdminPassword string
+ LoginCookieName string
+ LoginMaxLifetimeDays int
AnonymousEnabled bool
AnonymousOrgName string
@@ -215,7 +219,11 @@ type Cfg struct {
RendererLimit int
RendererLimitAlerting int
+ // Security
DisableBruteForceLoginProtection bool
+ CookieSecure bool
+ CookieSameSite http.SameSite
+
TempDataLifetime time.Duration
MetricsEndpointEnabled bool
MetricsEndpointBasicAuthUsername string
@@ -224,13 +232,11 @@ type Cfg struct {
DisableSanitizeHtml bool
EnterpriseLicensePath string
- LoginCookieName string
- LoginCookieMaxDays int
- LoginCookieRotation int
- LoginDeleteExpiredTokensAfterDays int
- LoginCookieSameSite http.SameSite
-
- SecurityHTTPSCookies bool
+ // Auth
+ LoginCookieName string
+ LoginMaxInactiveLifetimeDays int
+ LoginMaxLifetimeDays int
+ TokenRotationIntervalMinutes int
}
type CommandLineArgs struct {
@@ -554,30 +560,6 @@ func (cfg *Cfg) Load(args *CommandLineArgs) error {
ApplicationName = APP_NAME_ENTERPRISE
}
- //login
- login := iniFile.Section("login")
- cfg.LoginCookieName = login.Key("cookie_name").MustString("grafana_session")
- cfg.LoginCookieMaxDays = login.Key("login_remember_days").MustInt(7)
- cfg.LoginDeleteExpiredTokensAfterDays = login.Key("delete_expired_token_after_days").MustInt(30)
-
- samesiteString := login.Key("cookie_samesite").MustString("lax")
- validSameSiteValues := map[string]http.SameSite{
- "lax": http.SameSiteLaxMode,
- "strict": http.SameSiteStrictMode,
- "none": http.SameSiteDefaultMode,
- }
-
- if samesite, ok := validSameSiteValues[samesiteString]; ok {
- cfg.LoginCookieSameSite = samesite
- } else {
- cfg.LoginCookieSameSite = http.SameSiteLaxMode
- }
-
- cfg.LoginCookieRotation = login.Key("rotate_token_minutes").MustInt(10)
- if cfg.LoginCookieRotation < 2 {
- cfg.LoginCookieRotation = 2
- }
-
Env = iniFile.Section("").Key("app_mode").MustString("development")
InstanceName = iniFile.Section("").Key("instance_name").MustString("unknown_instance_name")
PluginsPath = makeAbsolute(iniFile.Section("paths").Key("plugins").String(), HomePath)
@@ -621,9 +603,26 @@ func (cfg *Cfg) Load(args *CommandLineArgs) error {
SecretKey = security.Key("secret_key").String()
DisableGravatar = security.Key("disable_gravatar").MustBool(true)
cfg.DisableBruteForceLoginProtection = security.Key("disable_brute_force_login_protection").MustBool(false)
- cfg.SecurityHTTPSCookies = security.Key("https_flag_cookies").MustBool(false)
DisableBruteForceLoginProtection = cfg.DisableBruteForceLoginProtection
+ CookieSecure = security.Key("cookie_secure").MustBool(false)
+ cfg.CookieSecure = CookieSecure
+
+ samesiteString := security.Key("cookie_samesite").MustString("lax")
+ validSameSiteValues := map[string]http.SameSite{
+ "lax": http.SameSiteLaxMode,
+ "strict": http.SameSiteStrictMode,
+ "none": http.SameSiteDefaultMode,
+ }
+
+ if samesite, ok := validSameSiteValues[samesiteString]; ok {
+ CookieSameSite = samesite
+ cfg.CookieSameSite = CookieSameSite
+ } else {
+ CookieSameSite = http.SameSiteLaxMode
+ cfg.CookieSameSite = CookieSameSite
+ }
+
// read snapshots settings
snapshots := iniFile.Section("snapshots")
ExternalSnapshotUrl = snapshots.Key("external_snapshot_url").String()
@@ -661,6 +660,19 @@ func (cfg *Cfg) Load(args *CommandLineArgs) error {
// auth
auth := iniFile.Section("auth")
+
+ LoginCookieName = auth.Key("login_cookie_name").MustString("grafana_session")
+ cfg.LoginCookieName = LoginCookieName
+ cfg.LoginMaxInactiveLifetimeDays = auth.Key("login_maximum_inactive_lifetime_days").MustInt(7)
+
+ LoginMaxLifetimeDays = auth.Key("login_maximum_lifetime_days").MustInt(30)
+ cfg.LoginMaxLifetimeDays = LoginMaxLifetimeDays
+
+ cfg.TokenRotationIntervalMinutes = auth.Key("token_rotation_interval_minutes").MustInt(10)
+ if cfg.TokenRotationIntervalMinutes < 2 {
+ cfg.TokenRotationIntervalMinutes = 2
+ }
+
DisableLoginForm = auth.Key("disable_login_form").MustBool(false)
DisableSignoutMenu = auth.Key("disable_signout_menu").MustBool(false)
OAuthAutoLogin = auth.Key("oauth_auto_login").MustBool(false)
diff --git a/pkg/tsdb/azuremonitor/azuremonitor-datasource.go b/pkg/tsdb/azuremonitor/azuremonitor-datasource.go
new file mode 100644
index 00000000000..cae8d8bfb73
--- /dev/null
+++ b/pkg/tsdb/azuremonitor/azuremonitor-datasource.go
@@ -0,0 +1,312 @@
+package azuremonitor
+
+import (
+ "context"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "io/ioutil"
+ "net/http"
+ "net/url"
+ "path"
+ "strings"
+ "time"
+
+ "github.com/grafana/grafana/pkg/api/pluginproxy"
+ "github.com/grafana/grafana/pkg/models"
+ "github.com/grafana/grafana/pkg/plugins"
+ "github.com/grafana/grafana/pkg/setting"
+ opentracing "github.com/opentracing/opentracing-go"
+ "golang.org/x/net/context/ctxhttp"
+
+ "github.com/grafana/grafana/pkg/components/null"
+ "github.com/grafana/grafana/pkg/components/simplejson"
+ "github.com/grafana/grafana/pkg/tsdb"
+)
+
+// AzureMonitorDatasource calls the Azure Monitor API - one of the four API's supported
+type AzureMonitorDatasource struct {
+ httpClient *http.Client
+ dsInfo *models.DataSource
+}
+
+var (
+ // 1m, 5m, 15m, 30m, 1h, 6h, 12h, 1d in milliseconds
+ allowedIntervalsMS = []int64{60000, 300000, 900000, 1800000, 3600000, 21600000, 43200000, 86400000}
+)
+
+// executeTimeSeriesQuery does the following:
+// 1. build the AzureMonitor url and querystring for each query
+// 2. executes each query by calling the Azure Monitor API
+// 3. parses the responses for each query into the timeseries format
+func (e *AzureMonitorDatasource) executeTimeSeriesQuery(ctx context.Context, originalQueries []*tsdb.Query, timeRange *tsdb.TimeRange) (*tsdb.Response, error) {
+ result := &tsdb.Response{
+ Results: map[string]*tsdb.QueryResult{},
+ }
+
+ queries, err := e.buildQueries(originalQueries, timeRange)
+ if err != nil {
+ return nil, err
+ }
+
+ for _, query := range queries {
+ queryRes, resp, err := e.executeQuery(ctx, query, originalQueries, timeRange)
+ if err != nil {
+ return nil, err
+ }
+ // azlog.Debug("AzureMonitor", "Response", resp)
+
+ err = e.parseResponse(queryRes, resp, query)
+ if err != nil {
+ queryRes.Error = err
+ }
+ result.Results[query.RefID] = queryRes
+ }
+
+ return result, nil
+}
+
+func (e *AzureMonitorDatasource) buildQueries(queries []*tsdb.Query, timeRange *tsdb.TimeRange) ([]*AzureMonitorQuery, error) {
+ azureMonitorQueries := []*AzureMonitorQuery{}
+ startTime, err := timeRange.ParseFrom()
+ if err != nil {
+ return nil, err
+ }
+
+ endTime, err := timeRange.ParseTo()
+ if err != nil {
+ return nil, err
+ }
+
+ for _, query := range queries {
+ var target string
+
+ azureMonitorTarget := query.Model.Get("azureMonitor").MustMap()
+ azlog.Debug("AzureMonitor", "target", azureMonitorTarget)
+
+ urlComponents := map[string]string{}
+ urlComponents["resourceGroup"] = fmt.Sprintf("%v", azureMonitorTarget["resourceGroup"])
+ urlComponents["metricDefinition"] = fmt.Sprintf("%v", azureMonitorTarget["metricDefinition"])
+ urlComponents["resourceName"] = fmt.Sprintf("%v", azureMonitorTarget["resourceName"])
+
+ ub := urlBuilder{
+ ResourceGroup: urlComponents["resourceGroup"],
+ MetricDefinition: urlComponents["metricDefinition"],
+ ResourceName: urlComponents["resourceName"],
+ }
+ azureURL := ub.Build()
+
+ alias := fmt.Sprintf("%v", azureMonitorTarget["alias"])
+
+ timeGrain := fmt.Sprintf("%v", azureMonitorTarget["timeGrain"])
+ if timeGrain == "auto" {
+ autoInterval := e.findClosestAllowedIntervalMS(query.IntervalMs)
+ tg := &TimeGrain{}
+ timeGrain, err = tg.createISO8601DurationFromIntervalMS(autoInterval)
+ if err != nil {
+ return nil, err
+ }
+ }
+
+ params := url.Values{}
+ params.Add("api-version", "2018-01-01")
+ params.Add("timespan", fmt.Sprintf("%v/%v", startTime.UTC().Format(time.RFC3339), endTime.UTC().Format(time.RFC3339)))
+ params.Add("interval", timeGrain)
+ params.Add("aggregation", fmt.Sprintf("%v", azureMonitorTarget["aggregation"]))
+ params.Add("metricnames", fmt.Sprintf("%v", azureMonitorTarget["metricName"]))
+
+ dimension := strings.TrimSpace(fmt.Sprintf("%v", azureMonitorTarget["dimension"]))
+ dimensionFilter := strings.TrimSpace(fmt.Sprintf("%v", azureMonitorTarget["dimensionFilter"]))
+ if azureMonitorTarget["dimension"] != nil && azureMonitorTarget["dimensionFilter"] != nil && len(dimension) > 0 && len(dimensionFilter) > 0 {
+ params.Add("$filter", fmt.Sprintf("%s eq '%s'", dimension, dimensionFilter))
+ }
+
+ target = params.Encode()
+
+ if setting.Env == setting.DEV {
+ azlog.Debug("Azuremonitor request", "params", params)
+ }
+
+ azureMonitorQueries = append(azureMonitorQueries, &AzureMonitorQuery{
+ URL: azureURL,
+ UrlComponents: urlComponents,
+ Target: target,
+ Params: params,
+ RefID: query.RefId,
+ Alias: alias,
+ })
+ }
+
+ return azureMonitorQueries, nil
+}
+
+func (e *AzureMonitorDatasource) executeQuery(ctx context.Context, query *AzureMonitorQuery, queries []*tsdb.Query, timeRange *tsdb.TimeRange) (*tsdb.QueryResult, AzureMonitorResponse, error) {
+ queryResult := &tsdb.QueryResult{Meta: simplejson.New(), RefId: query.RefID}
+
+ req, err := e.createRequest(ctx, e.dsInfo)
+ if err != nil {
+ queryResult.Error = err
+ return queryResult, AzureMonitorResponse{}, nil
+ }
+
+ req.URL.Path = path.Join(req.URL.Path, query.URL)
+ req.URL.RawQuery = query.Params.Encode()
+ queryResult.Meta.Set("rawQuery", req.URL.RawQuery)
+
+ span, ctx := opentracing.StartSpanFromContext(ctx, "azuremonitor query")
+ span.SetTag("target", query.Target)
+ span.SetTag("from", timeRange.From)
+ span.SetTag("until", timeRange.To)
+ span.SetTag("datasource_id", e.dsInfo.Id)
+ span.SetTag("org_id", e.dsInfo.OrgId)
+
+ defer span.Finish()
+
+ opentracing.GlobalTracer().Inject(
+ span.Context(),
+ opentracing.HTTPHeaders,
+ opentracing.HTTPHeadersCarrier(req.Header))
+
+ azlog.Debug("AzureMonitor", "Request URL", req.URL.String())
+ res, err := ctxhttp.Do(ctx, e.httpClient, req)
+ if err != nil {
+ queryResult.Error = err
+ return queryResult, AzureMonitorResponse{}, nil
+ }
+
+ data, err := e.unmarshalResponse(res)
+ if err != nil {
+ queryResult.Error = err
+ return queryResult, AzureMonitorResponse{}, nil
+ }
+
+ return queryResult, data, nil
+}
+
+func (e *AzureMonitorDatasource) createRequest(ctx context.Context, dsInfo *models.DataSource) (*http.Request, error) {
+ // find plugin
+ plugin, ok := plugins.DataSources[dsInfo.Type]
+ if !ok {
+ return nil, errors.New("Unable to find datasource plugin Azure Monitor")
+ }
+
+ var azureMonitorRoute *plugins.AppPluginRoute
+ for _, route := range plugin.Routes {
+ if route.Path == "azuremonitor" {
+ azureMonitorRoute = route
+ break
+ }
+ }
+
+ cloudName := dsInfo.JsonData.Get("cloudName").MustString("azuremonitor")
+ subscriptionID := dsInfo.JsonData.Get("subscriptionId").MustString()
+ proxyPass := fmt.Sprintf("%s/subscriptions/%s", cloudName, subscriptionID)
+
+ u, _ := url.Parse(dsInfo.Url)
+ u.Path = path.Join(u.Path, "render")
+
+ req, err := http.NewRequest(http.MethodGet, u.String(), nil)
+ if err != nil {
+ azlog.Error("Failed to create request", "error", err)
+ return nil, fmt.Errorf("Failed to create request. error: %v", err)
+ }
+
+ req.Header.Set("Content-Type", "application/json")
+ req.Header.Set("User-Agent", fmt.Sprintf("Grafana/%s", setting.BuildVersion))
+
+ pluginproxy.ApplyRoute(ctx, req, proxyPass, azureMonitorRoute, dsInfo)
+
+ return req, nil
+}
+
+func (e *AzureMonitorDatasource) unmarshalResponse(res *http.Response) (AzureMonitorResponse, error) {
+ body, err := ioutil.ReadAll(res.Body)
+ defer res.Body.Close()
+ if err != nil {
+ return AzureMonitorResponse{}, err
+ }
+
+ if res.StatusCode/100 != 2 {
+ azlog.Error("Request failed", "status", res.Status, "body", string(body))
+ return AzureMonitorResponse{}, fmt.Errorf(string(body))
+ }
+
+ var data AzureMonitorResponse
+ err = json.Unmarshal(body, &data)
+ if err != nil {
+ azlog.Error("Failed to unmarshal AzureMonitor response", "error", err, "status", res.Status, "body", string(body))
+ return AzureMonitorResponse{}, err
+ }
+
+ return data, nil
+}
+
+func (e *AzureMonitorDatasource) parseResponse(queryRes *tsdb.QueryResult, data AzureMonitorResponse, query *AzureMonitorQuery) error {
+ if len(data.Value) == 0 {
+ return nil
+ }
+
+ for _, series := range data.Value[0].Timeseries {
+ points := []tsdb.TimePoint{}
+
+ metadataName := ""
+ metadataValue := ""
+ if len(series.Metadatavalues) > 0 {
+ metadataName = series.Metadatavalues[0].Name.LocalizedValue
+ metadataValue = series.Metadatavalues[0].Value
+ }
+ defaultMetricName := formatLegendKey(query.UrlComponents["resourceName"], data.Value[0].Name.LocalizedValue, metadataName, metadataValue)
+
+ for _, point := range series.Data {
+ var value float64
+ switch query.Params.Get("aggregation") {
+ case "Average":
+ value = point.Average
+ case "Total":
+ value = point.Total
+ case "Maximum":
+ value = point.Maximum
+ case "Minimum":
+ value = point.Minimum
+ case "Count":
+ value = point.Count
+ default:
+ value = point.Count
+ }
+ points = append(points, tsdb.NewTimePoint(null.FloatFrom(value), float64((point.TimeStamp).Unix())*1000))
+ }
+
+ queryRes.Series = append(queryRes.Series, &tsdb.TimeSeries{
+ Name: defaultMetricName,
+ Points: points,
+ })
+ }
+
+ return nil
+}
+
+// findClosestAllowedIntervalMs is used for the auto time grain setting.
+// It finds the closest time grain from the list of allowed time grains for Azure Monitor
+// using the Grafana interval in milliseconds
+func (e *AzureMonitorDatasource) findClosestAllowedIntervalMS(intervalMs int64) int64 {
+ closest := allowedIntervalsMS[0]
+
+ for i, allowed := range allowedIntervalsMS {
+ if intervalMs > allowed {
+ if i+1 < len(allowedIntervalsMS) {
+ closest = allowedIntervalsMS[i+1]
+ } else {
+ closest = allowed
+ }
+ }
+ }
+ return closest
+}
+
+// formatLegendKey builds the legend key or timeseries name
+func formatLegendKey(resourceName string, metricName string, metadataName string, metadataValue string) string {
+ if len(metadataName) > 0 {
+ return fmt.Sprintf("%s{%s=%s}.%s", resourceName, metadataName, metadataValue, metricName)
+ }
+ return fmt.Sprintf("%s.%s", resourceName, metricName)
+}
diff --git a/pkg/tsdb/azuremonitor/azuremonitor-datasource_test.go b/pkg/tsdb/azuremonitor/azuremonitor-datasource_test.go
new file mode 100644
index 00000000000..b8d1d6cc266
--- /dev/null
+++ b/pkg/tsdb/azuremonitor/azuremonitor-datasource_test.go
@@ -0,0 +1,264 @@
+package azuremonitor
+
+import (
+ "encoding/json"
+ "fmt"
+ "io/ioutil"
+ "net/url"
+ "testing"
+ "time"
+
+ "github.com/grafana/grafana/pkg/components/simplejson"
+ "github.com/grafana/grafana/pkg/tsdb"
+
+ . "github.com/smartystreets/goconvey/convey"
+)
+
+func TestAzureMonitorDatasource(t *testing.T) {
+ Convey("AzureMonitorDatasource", t, func() {
+ datasource := &AzureMonitorDatasource{}
+
+ Convey("Parse queries from frontend and build AzureMonitor API queries", func() {
+ fromStart := time.Date(2018, 3, 15, 13, 0, 0, 0, time.UTC).In(time.Local)
+ tsdbQuery := &tsdb.TsdbQuery{
+ TimeRange: &tsdb.TimeRange{
+ From: fmt.Sprintf("%v", fromStart.Unix()*1000),
+ To: fmt.Sprintf("%v", fromStart.Add(34*time.Minute).Unix()*1000),
+ },
+ Queries: []*tsdb.Query{
+ {
+ Model: simplejson.NewFromAny(map[string]interface{}{
+ "azureMonitor": map[string]interface{}{
+ "timeGrain": "PT1M",
+ "aggregation": "Average",
+ "resourceGroup": "grafanastaging",
+ "resourceName": "grafana",
+ "metricDefinition": "Microsoft.Compute/virtualMachines",
+ "metricName": "Percentage CPU",
+ "alias": "testalias",
+ "queryType": "Azure Monitor",
+ },
+ }),
+ RefId: "A",
+ },
+ },
+ }
+ Convey("and is a normal query", func() {
+ queries, err := datasource.buildQueries(tsdbQuery.Queries, tsdbQuery.TimeRange)
+ So(err, ShouldBeNil)
+
+ So(len(queries), ShouldEqual, 1)
+ So(queries[0].RefID, ShouldEqual, "A")
+ So(queries[0].URL, ShouldEqual, "resourceGroups/grafanastaging/providers/Microsoft.Compute/virtualMachines/grafana/providers/microsoft.insights/metrics")
+ So(queries[0].Target, ShouldEqual, "aggregation=Average&api-version=2018-01-01&interval=PT1M&metricnames=Percentage+CPU×pan=2018-03-15T13%3A00%3A00Z%2F2018-03-15T13%3A34%3A00Z")
+ So(len(queries[0].Params), ShouldEqual, 5)
+ So(queries[0].Params["timespan"][0], ShouldEqual, "2018-03-15T13:00:00Z/2018-03-15T13:34:00Z")
+ So(queries[0].Params["api-version"][0], ShouldEqual, "2018-01-01")
+ So(queries[0].Params["aggregation"][0], ShouldEqual, "Average")
+ So(queries[0].Params["metricnames"][0], ShouldEqual, "Percentage CPU")
+ So(queries[0].Params["interval"][0], ShouldEqual, "PT1M")
+ So(queries[0].Alias, ShouldEqual, "testalias")
+ })
+
+ Convey("and has a dimension filter", func() {
+ tsdbQuery.Queries[0].Model = simplejson.NewFromAny(map[string]interface{}{
+ "azureMonitor": map[string]interface{}{
+ "timeGrain": "PT1M",
+ "aggregation": "Average",
+ "resourceGroup": "grafanastaging",
+ "resourceName": "grafana",
+ "metricDefinition": "Microsoft.Compute/virtualMachines",
+ "metricName": "Percentage CPU",
+ "alias": "testalias",
+ "queryType": "Azure Monitor",
+ "dimension": "blob",
+ "dimensionFilter": "*",
+ },
+ })
+
+ queries, err := datasource.buildQueries(tsdbQuery.Queries, tsdbQuery.TimeRange)
+ So(err, ShouldBeNil)
+
+ So(queries[0].Target, ShouldEqual, "%24filter=blob+eq+%27%2A%27&aggregation=Average&api-version=2018-01-01&interval=PT1M&metricnames=Percentage+CPU×pan=2018-03-15T13%3A00%3A00Z%2F2018-03-15T13%3A34%3A00Z")
+
+ })
+ })
+
+ Convey("Parse AzureMonitor API response in the time series format", func() {
+ Convey("when data from query aggregated as average to one time series", func() {
+ data, err := loadTestFile("./test-data/1-azure-monitor-response-avg.json")
+ So(err, ShouldBeNil)
+ So(data.Interval, ShouldEqual, "PT1M")
+
+ res := &tsdb.QueryResult{Meta: simplejson.New(), RefId: "A"}
+ query := &AzureMonitorQuery{
+ UrlComponents: map[string]string{
+ "resourceName": "grafana",
+ },
+ Params: url.Values{
+ "aggregation": {"Average"},
+ },
+ }
+ err = datasource.parseResponse(res, data, query)
+ So(err, ShouldBeNil)
+
+ So(len(res.Series), ShouldEqual, 1)
+ So(res.Series[0].Name, ShouldEqual, "grafana.Percentage CPU")
+ So(len(res.Series[0].Points), ShouldEqual, 5)
+
+ So(res.Series[0].Points[0][0].Float64, ShouldEqual, 2.0875)
+ So(res.Series[0].Points[0][1].Float64, ShouldEqual, 1549620780000)
+
+ So(res.Series[0].Points[1][0].Float64, ShouldEqual, 2.1525)
+ So(res.Series[0].Points[1][1].Float64, ShouldEqual, 1549620840000)
+
+ So(res.Series[0].Points[2][0].Float64, ShouldEqual, 2.155)
+ So(res.Series[0].Points[2][1].Float64, ShouldEqual, 1549620900000)
+
+ So(res.Series[0].Points[3][0].Float64, ShouldEqual, 3.6925)
+ So(res.Series[0].Points[3][1].Float64, ShouldEqual, 1549620960000)
+
+ So(res.Series[0].Points[4][0].Float64, ShouldEqual, 2.44)
+ So(res.Series[0].Points[4][1].Float64, ShouldEqual, 1549621020000)
+ })
+
+ Convey("when data from query aggregated as total to one time series", func() {
+ data, err := loadTestFile("./test-data/2-azure-monitor-response-total.json")
+ So(err, ShouldBeNil)
+
+ res := &tsdb.QueryResult{Meta: simplejson.New(), RefId: "A"}
+ query := &AzureMonitorQuery{
+ UrlComponents: map[string]string{
+ "resourceName": "grafana",
+ },
+ Params: url.Values{
+ "aggregation": {"Total"},
+ },
+ }
+ err = datasource.parseResponse(res, data, query)
+ So(err, ShouldBeNil)
+
+ So(res.Series[0].Points[0][0].Float64, ShouldEqual, 8.26)
+ So(res.Series[0].Points[0][1].Float64, ShouldEqual, 1549718940000)
+ })
+
+ Convey("when data from query aggregated as maximum to one time series", func() {
+ data, err := loadTestFile("./test-data/3-azure-monitor-response-maximum.json")
+ So(err, ShouldBeNil)
+
+ res := &tsdb.QueryResult{Meta: simplejson.New(), RefId: "A"}
+ query := &AzureMonitorQuery{
+ UrlComponents: map[string]string{
+ "resourceName": "grafana",
+ },
+ Params: url.Values{
+ "aggregation": {"Maximum"},
+ },
+ }
+ err = datasource.parseResponse(res, data, query)
+ So(err, ShouldBeNil)
+
+ So(res.Series[0].Points[0][0].Float64, ShouldEqual, 3.07)
+ So(res.Series[0].Points[0][1].Float64, ShouldEqual, 1549722360000)
+ })
+
+ Convey("when data from query aggregated as minimum to one time series", func() {
+ data, err := loadTestFile("./test-data/4-azure-monitor-response-minimum.json")
+ So(err, ShouldBeNil)
+
+ res := &tsdb.QueryResult{Meta: simplejson.New(), RefId: "A"}
+ query := &AzureMonitorQuery{
+ UrlComponents: map[string]string{
+ "resourceName": "grafana",
+ },
+ Params: url.Values{
+ "aggregation": {"Minimum"},
+ },
+ }
+ err = datasource.parseResponse(res, data, query)
+ So(err, ShouldBeNil)
+
+ So(res.Series[0].Points[0][0].Float64, ShouldEqual, 1.51)
+ So(res.Series[0].Points[0][1].Float64, ShouldEqual, 1549723380000)
+ })
+
+ Convey("when data from query aggregated as Count to one time series", func() {
+ data, err := loadTestFile("./test-data/5-azure-monitor-response-count.json")
+ So(err, ShouldBeNil)
+
+ res := &tsdb.QueryResult{Meta: simplejson.New(), RefId: "A"}
+ query := &AzureMonitorQuery{
+ UrlComponents: map[string]string{
+ "resourceName": "grafana",
+ },
+ Params: url.Values{
+ "aggregation": {"Count"},
+ },
+ }
+ err = datasource.parseResponse(res, data, query)
+ So(err, ShouldBeNil)
+
+ So(res.Series[0].Points[0][0].Float64, ShouldEqual, 4)
+ So(res.Series[0].Points[0][1].Float64, ShouldEqual, 1549723440000)
+ })
+
+ Convey("when data from query aggregated as total and has dimension filter", func() {
+ data, err := loadTestFile("./test-data/6-azure-monitor-response-multi-dimension.json")
+ So(err, ShouldBeNil)
+
+ res := &tsdb.QueryResult{Meta: simplejson.New(), RefId: "A"}
+ query := &AzureMonitorQuery{
+ UrlComponents: map[string]string{
+ "resourceName": "grafana",
+ },
+ Params: url.Values{
+ "aggregation": {"Average"},
+ },
+ }
+ err = datasource.parseResponse(res, data, query)
+ So(err, ShouldBeNil)
+ So(len(res.Series), ShouldEqual, 3)
+
+ So(res.Series[0].Name, ShouldEqual, "grafana{blobtype=PageBlob}.Blob Count")
+ So(res.Series[0].Points[0][0].Float64, ShouldEqual, 3)
+
+ So(res.Series[1].Name, ShouldEqual, "grafana{blobtype=BlockBlob}.Blob Count")
+ So(res.Series[1].Points[0][0].Float64, ShouldEqual, 1)
+
+ So(res.Series[2].Name, ShouldEqual, "grafana{blobtype=Azure Data Lake Storage}.Blob Count")
+ So(res.Series[2].Points[0][0].Float64, ShouldEqual, 0)
+ })
+ })
+
+ Convey("Find closest allowed interval for auto time grain", func() {
+ intervals := map[string]int64{
+ "3m": 180000,
+ "5m": 300000,
+ "10m": 600000,
+ "15m": 900000,
+ "1d": 86400000,
+ "2d": 172800000,
+ }
+
+ closest := datasource.findClosestAllowedIntervalMS(intervals["3m"])
+ So(closest, ShouldEqual, intervals["5m"])
+
+ closest = datasource.findClosestAllowedIntervalMS(intervals["10m"])
+ So(closest, ShouldEqual, intervals["15m"])
+
+ closest = datasource.findClosestAllowedIntervalMS(intervals["2d"])
+ So(closest, ShouldEqual, intervals["1d"])
+ })
+ })
+}
+
+func loadTestFile(path string) (AzureMonitorResponse, error) {
+ var data AzureMonitorResponse
+
+ jsonBody, err := ioutil.ReadFile(path)
+ if err != nil {
+ return data, err
+ }
+ err = json.Unmarshal(jsonBody, &data)
+ return data, err
+}
diff --git a/pkg/tsdb/azuremonitor/azuremonitor.go b/pkg/tsdb/azuremonitor/azuremonitor.go
new file mode 100644
index 00000000000..31a42d21a12
--- /dev/null
+++ b/pkg/tsdb/azuremonitor/azuremonitor.go
@@ -0,0 +1,70 @@
+package azuremonitor
+
+import (
+ "context"
+ "fmt"
+ "net/http"
+
+ "github.com/grafana/grafana/pkg/log"
+ "github.com/grafana/grafana/pkg/models"
+ "github.com/grafana/grafana/pkg/tsdb"
+)
+
+var (
+ azlog log.Logger
+)
+
+// AzureMonitorExecutor executes queries for the Azure Monitor datasource - all four services
+type AzureMonitorExecutor struct {
+ httpClient *http.Client
+ dsInfo *models.DataSource
+}
+
+// NewAzureMonitorExecutor initializes a http client
+func NewAzureMonitorExecutor(dsInfo *models.DataSource) (tsdb.TsdbQueryEndpoint, error) {
+ httpClient, err := dsInfo.GetHttpClient()
+ if err != nil {
+ return nil, err
+ }
+
+ return &AzureMonitorExecutor{
+ httpClient: httpClient,
+ dsInfo: dsInfo,
+ }, nil
+}
+
+func init() {
+ azlog = log.New("tsdb.azuremonitor")
+ tsdb.RegisterTsdbQueryEndpoint("grafana-azure-monitor-datasource", NewAzureMonitorExecutor)
+}
+
+// Query takes in the frontend queries, parses them into the query format
+// expected by chosen Azure Monitor service (Azure Monitor, App Insights etc.)
+// executes the queries against the API and parses the response into
+// the right format
+func (e *AzureMonitorExecutor) Query(ctx context.Context, dsInfo *models.DataSource, tsdbQuery *tsdb.TsdbQuery) (*tsdb.Response, error) {
+ var result *tsdb.Response
+ var err error
+
+ var azureMonitorQueries []*tsdb.Query
+
+ for _, query := range tsdbQuery.Queries {
+ queryType := query.Model.Get("queryType").MustString("")
+
+ switch queryType {
+ case "Azure Monitor":
+ azureMonitorQueries = append(azureMonitorQueries, query)
+ default:
+ return nil, fmt.Errorf("Alerting not supported for %s", queryType)
+ }
+ }
+
+ azDatasource := &AzureMonitorDatasource{
+ httpClient: e.httpClient,
+ dsInfo: e.dsInfo,
+ }
+
+ result, err = azDatasource.executeTimeSeriesQuery(ctx, azureMonitorQueries, tsdbQuery.TimeRange)
+
+ return result, err
+}
diff --git a/pkg/tsdb/azuremonitor/test-data/1-azure-monitor-response-avg.json b/pkg/tsdb/azuremonitor/test-data/1-azure-monitor-response-avg.json
new file mode 100644
index 00000000000..5fc84f6afa6
--- /dev/null
+++ b/pkg/tsdb/azuremonitor/test-data/1-azure-monitor-response-avg.json
@@ -0,0 +1,47 @@
+{
+ "cost": 0,
+ "timespan": "2019-02-08T10:13:50Z\/2019-02-08T16:13:50Z",
+ "interval": "PT1M",
+ "value": [
+ {
+ "id": "\/subscriptions\/xxx\/resourceGroups\/grafanastaging\/providers\/Microsoft.Compute\/virtualMachines\/grafana\/providers\/Microsoft.Insights\/metrics\/Percentage CPU",
+ "type": "Microsoft.Insights\/metrics",
+ "name": {
+ "value": "Percentage CPU",
+ "localizedValue": "Percentage CPU"
+ },
+ "unit": "Percent",
+ "timeseries": [
+ {
+ "metadatavalues": [
+
+ ],
+ "data": [
+ {
+ "timeStamp": "2019-02-08T10:13:00Z",
+ "average": 2.0875
+ },
+ {
+ "timeStamp": "2019-02-08T10:14:00Z",
+ "average": 2.1525
+ },
+ {
+ "timeStamp": "2019-02-08T10:15:00Z",
+ "average": 2.155
+ },
+ {
+ "timeStamp": "2019-02-08T10:16:00Z",
+ "average": 3.6925
+ },
+ {
+ "timeStamp": "2019-02-08T10:17:00Z",
+ "average": 2.44
+ }
+ ]
+ }
+ ]
+ }
+ ],
+ "namespace": "Microsoft.Compute\/virtualMachines",
+ "resourceregion": "westeurope"
+}
diff --git a/pkg/tsdb/azuremonitor/test-data/2-azure-monitor-response-total.json b/pkg/tsdb/azuremonitor/test-data/2-azure-monitor-response-total.json
new file mode 100644
index 00000000000..d0b22f1b02c
--- /dev/null
+++ b/pkg/tsdb/azuremonitor/test-data/2-azure-monitor-response-total.json
@@ -0,0 +1,47 @@
+{
+ "cost": 0,
+ "timespan": "2019-02-09T13:29:41Z\/2019-02-09T19:29:41Z",
+ "interval": "PT1M",
+ "value": [
+ {
+ "id": "\/subscriptions\/xxx\/resourceGroups\/grafanastaging\/providers\/Microsoft.Compute\/virtualMachines\/grafana\/providers\/Microsoft.Insights\/metrics\/Percentage CPU",
+ "type": "Microsoft.Insights\/metrics",
+ "name": {
+ "value": "Percentage CPU",
+ "localizedValue": "Percentage CPU"
+ },
+ "unit": "Percent",
+ "timeseries": [
+ {
+ "metadatavalues": [
+
+ ],
+ "data": [
+ {
+ "timeStamp": "2019-02-09T13:29:00Z",
+ "total": 8.26
+ },
+ {
+ "timeStamp": "2019-02-09T13:30:00Z",
+ "total": 8.7
+ },
+ {
+ "timeStamp": "2019-02-09T13:31:00Z",
+ "total": 14.82
+ },
+ {
+ "timeStamp": "2019-02-09T13:32:00Z",
+ "total": 10.07
+ },
+ {
+ "timeStamp": "2019-02-09T13:33:00Z",
+ "total": 8.52
+ }
+ ]
+ }
+ ]
+ }
+ ],
+ "namespace": "Microsoft.Compute\/virtualMachines",
+ "resourceregion": "westeurope"
+}
diff --git a/pkg/tsdb/azuremonitor/test-data/3-azure-monitor-response-maximum.json b/pkg/tsdb/azuremonitor/test-data/3-azure-monitor-response-maximum.json
new file mode 100644
index 00000000000..1e46cceb2be
--- /dev/null
+++ b/pkg/tsdb/azuremonitor/test-data/3-azure-monitor-response-maximum.json
@@ -0,0 +1,47 @@
+{
+ "cost": 0,
+ "timespan": "2019-02-09T14:26:12Z\/2019-02-09T20:26:12Z",
+ "interval": "PT1M",
+ "value": [
+ {
+ "id": "\/subscriptions\/xxx\/resourceGroups\/grafanastaging\/providers\/Microsoft.Compute\/virtualMachines\/grafana\/providers\/Microsoft.Insights\/metrics\/Percentage CPU",
+ "type": "Microsoft.Insights\/metrics",
+ "name": {
+ "value": "Percentage CPU",
+ "localizedValue": "Percentage CPU"
+ },
+ "unit": "Percent",
+ "timeseries": [
+ {
+ "metadatavalues": [
+
+ ],
+ "data": [
+ {
+ "timeStamp": "2019-02-09T14:26:00Z",
+ "maximum": 3.07
+ },
+ {
+ "timeStamp": "2019-02-09T14:27:00Z",
+ "maximum": 2.92
+ },
+ {
+ "timeStamp": "2019-02-09T14:28:00Z",
+ "maximum": 2.87
+ },
+ {
+ "timeStamp": "2019-02-09T14:29:00Z",
+ "maximum": 2.27
+ },
+ {
+ "timeStamp": "2019-02-09T14:30:00Z",
+ "maximum": 2.52
+ }
+ ]
+ }
+ ]
+ }
+ ],
+ "namespace": "Microsoft.Compute\/virtualMachines",
+ "resourceregion": "westeurope"
+}
diff --git a/pkg/tsdb/azuremonitor/test-data/4-azure-monitor-response-minimum.json b/pkg/tsdb/azuremonitor/test-data/4-azure-monitor-response-minimum.json
new file mode 100644
index 00000000000..16310614214
--- /dev/null
+++ b/pkg/tsdb/azuremonitor/test-data/4-azure-monitor-response-minimum.json
@@ -0,0 +1,47 @@
+{
+ "cost": 0,
+ "timespan": "2019-02-09T14:43:21Z\/2019-02-09T20:43:21Z",
+ "interval": "PT1M",
+ "value": [
+ {
+ "id": "\/subscriptions\/xxx\/resourceGroups\/grafanastaging\/providers\/Microsoft.Compute\/virtualMachines\/grafana\/providers\/Microsoft.Insights\/metrics\/Percentage CPU",
+ "type": "Microsoft.Insights\/metrics",
+ "name": {
+ "value": "Percentage CPU",
+ "localizedValue": "Percentage CPU"
+ },
+ "unit": "Percent",
+ "timeseries": [
+ {
+ "metadatavalues": [
+
+ ],
+ "data": [
+ {
+ "timeStamp": "2019-02-09T14:43:00Z",
+ "minimum": 1.51
+ },
+ {
+ "timeStamp": "2019-02-09T14:44:00Z",
+ "minimum": 2.38
+ },
+ {
+ "timeStamp": "2019-02-09T14:45:00Z",
+ "minimum": 1.69
+ },
+ {
+ "timeStamp": "2019-02-09T14:46:00Z",
+ "minimum": 2.27
+ },
+ {
+ "timeStamp": "2019-02-09T14:47:00Z",
+ "minimum": 1.96
+ }
+ ]
+ }
+ ]
+ }
+ ],
+ "namespace": "Microsoft.Compute\/virtualMachines",
+ "resourceregion": "westeurope"
+}
diff --git a/pkg/tsdb/azuremonitor/test-data/5-azure-monitor-response-count.json b/pkg/tsdb/azuremonitor/test-data/5-azure-monitor-response-count.json
new file mode 100644
index 00000000000..91afc33f070
--- /dev/null
+++ b/pkg/tsdb/azuremonitor/test-data/5-azure-monitor-response-count.json
@@ -0,0 +1,47 @@
+{
+ "cost": 0,
+ "timespan": "2019-02-09T14:44:52Z\/2019-02-09T20:44:52Z",
+ "interval": "PT1M",
+ "value": [
+ {
+ "id": "\/subscriptions\/xxx\/resourceGroups\/grafanastaging\/providers\/Microsoft.Compute\/virtualMachines\/grafana\/providers\/Microsoft.Insights\/metrics\/Percentage CPU",
+ "type": "Microsoft.Insights\/metrics",
+ "name": {
+ "value": "Percentage CPU",
+ "localizedValue": "Percentage CPU"
+ },
+ "unit": "Percent",
+ "timeseries": [
+ {
+ "metadatavalues": [
+
+ ],
+ "data": [
+ {
+ "timeStamp": "2019-02-09T14:44:00Z",
+ "count": 4
+ },
+ {
+ "timeStamp": "2019-02-09T14:45:00Z",
+ "count": 4
+ },
+ {
+ "timeStamp": "2019-02-09T14:46:00Z",
+ "count": 4
+ },
+ {
+ "timeStamp": "2019-02-09T14:47:00Z",
+ "count": 4
+ },
+ {
+ "timeStamp": "2019-02-09T14:48:00Z",
+ "count": 4
+ }
+ ]
+ }
+ ]
+ }
+ ],
+ "namespace": "Microsoft.Compute\/virtualMachines",
+ "resourceregion": "westeurope"
+}
diff --git a/pkg/tsdb/azuremonitor/test-data/6-azure-monitor-response-multi-dimension.json b/pkg/tsdb/azuremonitor/test-data/6-azure-monitor-response-multi-dimension.json
new file mode 100644
index 00000000000..dddcef0e79c
--- /dev/null
+++ b/pkg/tsdb/azuremonitor/test-data/6-azure-monitor-response-multi-dimension.json
@@ -0,0 +1,128 @@
+{
+ "cost": 0,
+ "timespan": "2019-02-09T15:21:39Z\/2019-02-09T21:21:39Z",
+ "interval": "PT1H",
+ "value": [
+ {
+ "id": "\/subscriptions\/xxx\/resourceGroups\/grafanastaging\/providers\/Microsoft.Storage\/storageAccounts\/grafanastaging\/blobServices\/default\/providers\/Microsoft.Insights\/metrics\/BlobCount",
+ "type": "Microsoft.Insights\/metrics",
+ "name": {
+ "value": "BlobCount",
+ "localizedValue": "Blob Count"
+ },
+ "unit": "Count",
+ "timeseries": [
+ {
+ "metadatavalues": [
+ {
+ "name": {
+ "value": "blobtype",
+ "localizedValue": "blobtype"
+ },
+ "value": "PageBlob"
+ }
+ ],
+ "data": [
+ {
+ "timeStamp": "2019-02-09T15:21:00Z",
+ "average": 3
+ },
+ {
+ "timeStamp": "2019-02-09T16:21:00Z",
+ "average": 3
+ },
+ {
+ "timeStamp": "2019-02-09T17:21:00Z",
+ "average": 3
+ },
+ {
+ "timeStamp": "2019-02-09T18:21:00Z",
+ "average": 3
+ },
+ {
+ "timeStamp": "2019-02-09T19:21:00Z",
+ "average": 3
+ },
+ {
+ "timeStamp": "2019-02-09T20:21:00Z"
+ }
+ ]
+ },
+ {
+ "metadatavalues": [
+ {
+ "name": {
+ "value": "blobtype",
+ "localizedValue": "blobtype"
+ },
+ "value": "BlockBlob"
+ }
+ ],
+ "data": [
+ {
+ "timeStamp": "2019-02-09T15:21:00Z",
+ "average": 1
+ },
+ {
+ "timeStamp": "2019-02-09T16:21:00Z",
+ "average": 1
+ },
+ {
+ "timeStamp": "2019-02-09T17:21:00Z",
+ "average": 1
+ },
+ {
+ "timeStamp": "2019-02-09T18:21:00Z",
+ "average": 1
+ },
+ {
+ "timeStamp": "2019-02-09T19:21:00Z",
+ "average": 1
+ },
+ {
+ "timeStamp": "2019-02-09T20:21:00Z"
+ }
+ ]
+ },
+ {
+ "metadatavalues": [
+ {
+ "name": {
+ "value": "blobtype",
+ "localizedValue": "blobtype"
+ },
+ "value": "Azure Data Lake Storage"
+ }
+ ],
+ "data": [
+ {
+ "timeStamp": "2019-02-09T15:21:00Z",
+ "average": 0
+ },
+ {
+ "timeStamp": "2019-02-09T16:21:00Z",
+ "average": 0
+ },
+ {
+ "timeStamp": "2019-02-09T17:21:00Z",
+ "average": 0
+ },
+ {
+ "timeStamp": "2019-02-09T18:21:00Z",
+ "average": 0
+ },
+ {
+ "timeStamp": "2019-02-09T19:21:00Z",
+ "average": 0
+ },
+ {
+ "timeStamp": "2019-02-09T20:21:00Z"
+ }
+ ]
+ }
+ ]
+ }
+ ],
+ "namespace": "Microsoft.Storage\/storageAccounts\/blobServices",
+ "resourceregion": "westeurope"
+}
diff --git a/pkg/tsdb/azuremonitor/time-grain.go b/pkg/tsdb/azuremonitor/time-grain.go
new file mode 100644
index 00000000000..425e39b6208
--- /dev/null
+++ b/pkg/tsdb/azuremonitor/time-grain.go
@@ -0,0 +1,52 @@
+package azuremonitor
+
+import (
+ "fmt"
+ "strconv"
+ "strings"
+ "time"
+
+ "github.com/grafana/grafana/pkg/tsdb"
+)
+
+// TimeGrain handles convertions between
+// the ISO 8601 Duration format (PT1H), Kbn units (1h) and Time Grains (1 hour)
+// Also handles using the automatic Grafana interval to calculate a ISO 8601 Duration.
+type TimeGrain struct{}
+
+var (
+ smallTimeUnits = []string{"hour", "minute", "h", "m"}
+)
+
+func (tg *TimeGrain) createISO8601DurationFromIntervalMS(interval int64) (string, error) {
+ formatted := tsdb.FormatDuration(time.Duration(interval) * time.Millisecond)
+
+ if strings.Contains(formatted, "ms") {
+ return "PT1M", nil
+ }
+
+ timeValueString := formatted[0 : len(formatted)-1]
+ timeValue, err := strconv.Atoi(timeValueString)
+ if err != nil {
+ return "", fmt.Errorf("Could not parse interval %v to an ISO 8061 duration", interval)
+ }
+
+ unit := formatted[len(formatted)-1:]
+
+ if unit == "s" && timeValue < 60 {
+ // minimum interval is 1m for Azure Monitor
+ return "PT1M", nil
+ }
+
+ return tg.createISO8601Duration(timeValue, unit), nil
+}
+
+func (tg *TimeGrain) createISO8601Duration(timeValue int, timeUnit string) string {
+ for _, smallTimeUnit := range smallTimeUnits {
+ if timeUnit == smallTimeUnit {
+ return fmt.Sprintf("PT%v%v", timeValue, strings.ToUpper(timeUnit[0:1]))
+ }
+ }
+
+ return fmt.Sprintf("P%v%v", timeValue, strings.ToUpper(timeUnit[0:1]))
+}
diff --git a/pkg/tsdb/azuremonitor/time-grain_test.go b/pkg/tsdb/azuremonitor/time-grain_test.go
new file mode 100644
index 00000000000..2df3c92b0ff
--- /dev/null
+++ b/pkg/tsdb/azuremonitor/time-grain_test.go
@@ -0,0 +1,71 @@
+package azuremonitor
+
+import (
+ "testing"
+
+ . "github.com/smartystreets/goconvey/convey"
+)
+
+func TestTimeGrain(t *testing.T) {
+ Convey("TimeGrain", t, func() {
+ tgc := &TimeGrain{}
+
+ Convey("create ISO 8601 Duration", func() {
+ Convey("when given a time unit smaller than a day", func() {
+ minuteKbnDuration := tgc.createISO8601Duration(1, "m")
+ hourKbnDuration := tgc.createISO8601Duration(2, "h")
+ minuteDuration := tgc.createISO8601Duration(1, "minute")
+ hourDuration := tgc.createISO8601Duration(2, "hour")
+
+ Convey("should convert it to a time duration", func() {
+ So(minuteKbnDuration, ShouldEqual, "PT1M")
+ So(hourKbnDuration, ShouldEqual, "PT2H")
+
+ So(minuteDuration, ShouldEqual, "PT1M")
+ So(hourDuration, ShouldEqual, "PT2H")
+ })
+ })
+
+ Convey("when given the day time unit", func() {
+ kbnDuration := tgc.createISO8601Duration(1, "d")
+ duration := tgc.createISO8601Duration(2, "day")
+
+ Convey("should convert it to a date duration", func() {
+ So(kbnDuration, ShouldEqual, "P1D")
+ So(duration, ShouldEqual, "P2D")
+ })
+ })
+ })
+
+ Convey("create ISO 8601 Duration from Grafana interval in milliseconds", func() {
+ Convey("and interval is less than a minute", func() {
+ durationMS, err := tgc.createISO8601DurationFromIntervalMS(100)
+ So(err, ShouldBeNil)
+
+ durationS, err := tgc.createISO8601DurationFromIntervalMS(59999)
+ So(err, ShouldBeNil)
+
+ Convey("should be rounded up to a minute as is the minimum interval for Azure Monitor", func() {
+ So(durationMS, ShouldEqual, "PT1M")
+ So(durationS, ShouldEqual, "PT1M")
+ })
+ })
+
+ Convey("and interval is more than a minute", func() {
+ intervals := map[string]int64{
+ "10m": 600000,
+ "2d": 172800000,
+ }
+ durationM, err := tgc.createISO8601DurationFromIntervalMS(intervals["10m"])
+ So(err, ShouldBeNil)
+ durationD, err := tgc.createISO8601DurationFromIntervalMS(intervals["2d"])
+ So(err, ShouldBeNil)
+
+ Convey("should be rounded up to a minute as is the minimum interval for Azure Monitor", func() {
+ So(durationM, ShouldEqual, "PT10M")
+ So(durationD, ShouldEqual, "P2D")
+ })
+ })
+ })
+ })
+}
diff --git a/pkg/tsdb/azuremonitor/types.go b/pkg/tsdb/azuremonitor/types.go
new file mode 100644
index 00000000000..b547c71f185
--- /dev/null
+++ b/pkg/tsdb/azuremonitor/types.go
@@ -0,0 +1,77 @@
+package azuremonitor
+
+import (
+ "net/url"
+ "time"
+)
+
+// AzureMonitorQuery is the query for all the services as they have similar queries
+// with a url, a querystring and an alias field
+type AzureMonitorQuery struct {
+ URL string
+ UrlComponents map[string]string
+ Target string
+ Params url.Values
+ RefID string
+ Alias string
+}
+
+// AzureMonitorResponse is the json response from the Azure Monitor API
+type AzureMonitorResponse struct {
+ Cost int `json:"cost"`
+ Timespan string `json:"timespan"`
+ Interval string `json:"interval"`
+ Value []struct {
+ ID string `json:"id"`
+ Type string `json:"type"`
+ Name struct {
+ Value string `json:"value"`
+ LocalizedValue string `json:"localizedValue"`
+ } `json:"name"`
+ Unit string `json:"unit"`
+ Timeseries []struct {
+ Metadatavalues []struct {
+ Name struct {
+ Value string `json:"value"`
+ LocalizedValue string `json:"localizedValue"`
+ } `json:"name"`
+ Value string `json:"value"`
+ } `json:"metadatavalues"`
+ Data []struct {
+ TimeStamp time.Time `json:"timeStamp"`
+ Average float64 `json:"average,omitempty"`
+ Total float64 `json:"total,omitempty"`
+ Count float64 `json:"count,omitempty"`
+ Maximum float64 `json:"maximum,omitempty"`
+ Minimum float64 `json:"minimum,omitempty"`
+ } `json:"data"`
+ } `json:"timeseries"`
+ } `json:"value"`
+ Namespace string `json:"namespace"`
+ Resourceregion string `json:"resourceregion"`
+}
+
+// ApplicationInsightsResponse is the json response from the Application Insights API
+type ApplicationInsightsResponse struct {
+ Tables []struct {
+ TableName string `json:"TableName"`
+ Columns []struct {
+ ColumnName string `json:"ColumnName"`
+ DataType string `json:"DataType"`
+ ColumnType string `json:"ColumnType"`
+ } `json:"Columns"`
+ Rows [][]interface{} `json:"Rows"`
+ } `json:"Tables"`
+}
+
+// AzureLogAnalyticsResponse is the json response object from the Azure Log Analytics API.
+type AzureLogAnalyticsResponse struct {
+ Tables []struct {
+ Name string `json:"name"`
+ Columns []struct {
+ Name string `json:"name"`
+ Type string `json:"type"`
+ } `json:"columns"`
+ Rows [][]interface{} `json:"rows"`
+ } `json:"tables"`
+}
diff --git a/pkg/tsdb/azuremonitor/url-builder.go b/pkg/tsdb/azuremonitor/url-builder.go
new file mode 100644
index 00000000000..c252048f517
--- /dev/null
+++ b/pkg/tsdb/azuremonitor/url-builder.go
@@ -0,0 +1,28 @@
+package azuremonitor
+
+import (
+ "fmt"
+ "strings"
+)
+
+// urlBuilder builds the URL for calling the Azure Monitor API
+type urlBuilder struct {
+ ResourceGroup string
+ MetricDefinition string
+ ResourceName string
+}
+
+// Build checks the metric definition property to see which form of the url
+// should be returned
+func (ub *urlBuilder) Build() string {
+
+ if strings.Count(ub.MetricDefinition, "/") > 1 {
+ rn := strings.Split(ub.ResourceName, "/")
+ lastIndex := strings.LastIndex(ub.MetricDefinition, "/")
+ service := ub.MetricDefinition[lastIndex+1:]
+ md := ub.MetricDefinition[0:lastIndex]
+ return fmt.Sprintf("resourceGroups/%s/providers/%s/%s/%s/%s/providers/microsoft.insights/metrics", ub.ResourceGroup, md, rn[0], service, rn[1])
+ }
+
+ return fmt.Sprintf("resourceGroups/%s/providers/%s/%s/providers/microsoft.insights/metrics", ub.ResourceGroup, ub.MetricDefinition, ub.ResourceName)
+}
diff --git a/pkg/tsdb/azuremonitor/url-builder_test.go b/pkg/tsdb/azuremonitor/url-builder_test.go
new file mode 100644
index 00000000000..85c4f81bc83
--- /dev/null
+++ b/pkg/tsdb/azuremonitor/url-builder_test.go
@@ -0,0 +1,45 @@
+package azuremonitor
+
+import (
+ "testing"
+
+ . "github.com/smartystreets/goconvey/convey"
+)
+
+func TestURLBuilder(t *testing.T) {
+ Convey("AzureMonitor URL Builder", t, func() {
+
+ Convey("when metric definition is in the short form", func() {
+ ub := &urlBuilder{
+ ResourceGroup: "rg",
+ MetricDefinition: "Microsoft.Compute/virtualMachines",
+ ResourceName: "rn",
+ }
+
+ url := ub.Build()
+ So(url, ShouldEqual, "resourceGroups/rg/providers/Microsoft.Compute/virtualMachines/rn/providers/microsoft.insights/metrics")
+ })
+
+ Convey("when metric definition is Microsoft.Storage/storageAccounts/blobServices", func() {
+ ub := &urlBuilder{
+ ResourceGroup: "rg",
+ MetricDefinition: "Microsoft.Storage/storageAccounts/blobServices",
+ ResourceName: "rn1/default",
+ }
+
+ url := ub.Build()
+ So(url, ShouldEqual, "resourceGroups/rg/providers/Microsoft.Storage/storageAccounts/rn1/blobServices/default/providers/microsoft.insights/metrics")
+ })
+
+ Convey("when metric definition is Microsoft.Storage/storageAccounts/fileServices", func() {
+ ub := &urlBuilder{
+ ResourceGroup: "rg",
+ MetricDefinition: "Microsoft.Storage/storageAccounts/fileServices",
+ ResourceName: "rn1/default",
+ }
+
+ url := ub.Build()
+ So(url, ShouldEqual, "resourceGroups/rg/providers/Microsoft.Storage/storageAccounts/rn1/fileServices/default/providers/microsoft.insights/metrics")
+ })
+ })
+}
diff --git a/pkg/tsdb/cloudwatch/metric_find_query.go b/pkg/tsdb/cloudwatch/metric_find_query.go
index 34181d19673..ddda26dfd24 100644
--- a/pkg/tsdb/cloudwatch/metric_find_query.go
+++ b/pkg/tsdb/cloudwatch/metric_find_query.go
@@ -55,6 +55,7 @@ func init() {
"AWS/DynamoDB": {"ConditionalCheckFailedRequests", "ConsumedReadCapacityUnits", "ConsumedWriteCapacityUnits", "OnlineIndexConsumedWriteCapacity", "OnlineIndexPercentageProgress", "OnlineIndexThrottleEvents", "ProvisionedReadCapacityUnits", "ProvisionedWriteCapacityUnits", "ReadThrottleEvents", "ReturnedBytes", "ReturnedItemCount", "ReturnedRecordsCount", "SuccessfulRequestLatency", "SystemErrors", "TimeToLiveDeletedItemCount", "ThrottledRequests", "UserErrors", "WriteThrottleEvents"},
"AWS/EBS": {"VolumeReadBytes", "VolumeWriteBytes", "VolumeReadOps", "VolumeWriteOps", "VolumeTotalReadTime", "VolumeTotalWriteTime", "VolumeIdleTime", "VolumeQueueLength", "VolumeThroughputPercentage", "VolumeConsumedReadWriteOps", "BurstBalance"},
"AWS/EC2": {"CPUCreditUsage", "CPUCreditBalance", "CPUUtilization", "DiskReadOps", "DiskWriteOps", "DiskReadBytes", "DiskWriteBytes", "NetworkIn", "NetworkOut", "NetworkPacketsIn", "NetworkPacketsOut", "StatusCheckFailed", "StatusCheckFailed_Instance", "StatusCheckFailed_System"},
+ "AWS/EC2/API": {"ClientErrors", "RequestLimitExceeded", "ServerErrors", "SuccessfulCalls"},
"AWS/EC2Spot": {"AvailableInstancePoolsCount", "BidsSubmittedForCapacity", "EligibleInstancePoolCount", "FulfilledCapacity", "MaxPercentCapacityAllocation", "PendingCapacity", "PercentCapacityAllocation", "TargetCapacity", "TerminatingCapacity"},
"AWS/ECS": {"CPUReservation", "MemoryReservation", "CPUUtilization", "MemoryUtilization"},
"AWS/EFS": {"BurstCreditBalance", "ClientConnections", "DataReadIOBytes", "DataWriteIOBytes", "MetadataIOBytes", "TotalIOBytes", "PermittedThroughput", "PercentIOLimit"},
@@ -133,6 +134,7 @@ func init() {
"AWS/DynamoDB": {"TableName", "GlobalSecondaryIndexName", "Operation", "StreamLabel"},
"AWS/EBS": {"VolumeId"},
"AWS/EC2": {"AutoScalingGroupName", "ImageId", "InstanceId", "InstanceType"},
+ "AWS/EC2/API": {},
"AWS/EC2Spot": {"AvailabilityZone", "FleetRequestId", "InstanceType"},
"AWS/ECS": {"ClusterName", "ServiceName"},
"AWS/EFS": {"FileSystemId"},
diff --git a/pkg/tsdb/interval.go b/pkg/tsdb/interval.go
index fd6adee39d7..7819ef3ecad 100644
--- a/pkg/tsdb/interval.go
+++ b/pkg/tsdb/interval.go
@@ -59,11 +59,11 @@ func (ic *intervalCalculator) Calculate(timerange *TimeRange, minInterval time.D
interval := time.Duration((to - from) / defaultRes)
if interval < minInterval {
- return Interval{Text: formatDuration(minInterval), Value: minInterval}
+ return Interval{Text: FormatDuration(minInterval), Value: minInterval}
}
rounded := roundInterval(interval)
- return Interval{Text: formatDuration(rounded), Value: rounded}
+ return Interval{Text: FormatDuration(rounded), Value: rounded}
}
func GetIntervalFrom(dsInfo *models.DataSource, queryModel *simplejson.Json, defaultInterval time.Duration) (time.Duration, error) {
@@ -89,7 +89,8 @@ func GetIntervalFrom(dsInfo *models.DataSource, queryModel *simplejson.Json, def
return parsedInterval, nil
}
-func formatDuration(inter time.Duration) string {
+// FormatDuration converts a duration into the kbn format e.g. 1m 2h or 3d
+func FormatDuration(inter time.Duration) string {
if inter >= year {
return fmt.Sprintf("%dy", inter/year)
}
diff --git a/pkg/tsdb/interval_test.go b/pkg/tsdb/interval_test.go
index 941b08dd554..4cd3fcea532 100644
--- a/pkg/tsdb/interval_test.go
+++ b/pkg/tsdb/interval_test.go
@@ -51,11 +51,11 @@ func TestInterval(t *testing.T) {
})
Convey("Format value", func() {
- So(formatDuration(time.Second*61), ShouldEqual, "1m")
- So(formatDuration(time.Millisecond*30), ShouldEqual, "30ms")
- So(formatDuration(time.Hour*23), ShouldEqual, "23h")
- So(formatDuration(time.Hour*24), ShouldEqual, "1d")
- So(formatDuration(time.Hour*24*367), ShouldEqual, "1y")
+ So(FormatDuration(time.Second*61), ShouldEqual, "1m")
+ So(FormatDuration(time.Millisecond*30), ShouldEqual, "30ms")
+ So(FormatDuration(time.Hour*23), ShouldEqual, "23h")
+ So(FormatDuration(time.Hour*24), ShouldEqual, "1d")
+ So(FormatDuration(time.Hour*24*367), ShouldEqual, "1y")
})
})
}
diff --git a/pkg/tsdb/mysql/mysql.go b/pkg/tsdb/mysql/mysql.go
index 35b03e489a0..d307e12166c 100644
--- a/pkg/tsdb/mysql/mysql.go
+++ b/pkg/tsdb/mysql/mysql.go
@@ -32,6 +32,18 @@ func newMysqlQueryEndpoint(datasource *models.DataSource) (tsdb.TsdbQueryEndpoin
datasource.Url,
datasource.Database,
)
+
+ tlsConfig, err := datasource.GetTLSConfig()
+ if err != nil {
+ return nil, err
+ }
+
+ if tlsConfig.RootCAs != nil || len(tlsConfig.Certificates) > 0 {
+ tlsConfigString := fmt.Sprintf("ds%d", datasource.Id)
+ mysql.RegisterTLSConfig(tlsConfigString, tlsConfig)
+ cnnstr += "&tls=" + tlsConfigString
+ }
+
logger.Debug("getEngine", "connection", cnnstr)
config := tsdb.SqlQueryEndpointConfiguration{
diff --git a/public/app/core/angular_wrappers.ts b/public/app/core/angular_wrappers.ts
index 4806275e87d..6db442e7470 100644
--- a/public/app/core/angular_wrappers.ts
+++ b/public/app/core/angular_wrappers.ts
@@ -9,7 +9,7 @@ import { TagFilter } from './components/TagFilter/TagFilter';
import { SideMenu } from './components/sidemenu/SideMenu';
import { MetricSelect } from './components/Select/MetricSelect';
import AppNotificationList from './components/AppNotifications/AppNotificationList';
-import { ColorPicker, SeriesColorPickerPopover } from '@grafana/ui';
+import { ColorPicker, SeriesColorPickerPopoverWithTheme } from '@grafana/ui';
export function registerAngularDirectives() {
react2AngularDirective('passwordStrength', PasswordStrength, ['password']);
@@ -27,7 +27,7 @@ export function registerAngularDirectives() {
'color',
['onChange', { watchDepth: 'reference', wrapApply: true }],
]);
- react2AngularDirective('seriesColorPickerPopover', SeriesColorPickerPopover, [
+ react2AngularDirective('seriesColorPickerPopover', SeriesColorPickerPopoverWithTheme, [
'color',
'series',
'onColorChange',
diff --git a/public/app/core/app_events.ts b/public/app/core/app_events.ts
index 6af7913167b..1951fd87001 100644
--- a/public/app/core/app_events.ts
+++ b/public/app/core/app_events.ts
@@ -1,4 +1,5 @@
import { Emitter } from './utils/emitter';
-const appEvents = new Emitter();
+export const appEvents = new Emitter();
+
export default appEvents;
diff --git a/public/app/core/components/AlertBox/AlertBox.tsx b/public/app/core/components/AlertBox/AlertBox.tsx
new file mode 100644
index 00000000000..c99bf11ed7c
--- /dev/null
+++ b/public/app/core/components/AlertBox/AlertBox.tsx
@@ -0,0 +1,42 @@
+import React, { FunctionComponent } from 'react';
+import { AppNotificationSeverity } from 'app/types';
+
+interface Props {
+ title: string;
+ icon?: string;
+ text?: string;
+ severity: AppNotificationSeverity;
+ onClose?: () => void;
+}
+
+function getIconFromSeverity(severity: AppNotificationSeverity): string {
+ switch (severity) {
+ case AppNotificationSeverity.Error: {
+ return 'fa fa-exclamation-triangle';
+ }
+ case AppNotificationSeverity.Success: {
+ return 'fa fa-check';
+ }
+ default:
+ return null;
+ }
+}
+
+export const AlertBox: FunctionComponent = ({ title, icon, text, severity, onClose }) => {
+ return (
+
+
+
+
+
{title}
+ {text &&
{text}
}
+
+ {onClose && (
+
+
+ )}
+
= props => {
@@ -22,7 +23,12 @@ export const FadeIn: FC = props => {
};
return (
-
+
{state => (
-
+
{linkButton.title}