dashboard: CPU, memory, diskIO and traffic on the footer (#15950)

* dashboard: footer, deep state update

* dashboard: resolve asset path

* dashboard: prevent state update on every reconnection

* dashboard: fix linter issue

* dashboard, cmd: minor UI fix, include commit hash

* dashboard: gitCommit renamed to commit

* dashboard: move the geth version to the right, make commit optional

* dashboard: memory, traffic and CPU on footer

* dashboard: fix merge

* dashboard: CPU, diskIO on footer

* dashboard: rename variables, use group declaration

* dashboard: docs

dashboard/assets/.eslintrc

@@ -40,6 +40,9 @@
         'react/jsx-indent':       ['error', 'tab'],
         'react/jsx-indent-props': ['error', 'tab'],
         'react/prefer-stateless-function': 'off',
+        'jsx-quotes':  ['error', 'prefer-single'],
+        'no-plusplus': 'off',
+        'no-console':  ['error', { allow: ['error'] }],
 
         // Specifies the maximum length of a line.
         'max-len': ['warn', 120, 2, {
@@ -49,7 +52,7 @@
             'ignoreStrings':          true,
             'ignoreTemplateLiterals': true,
         }],
-        // Enforces spacing between keys and values in object literal properties.
+        // Enforces consistent spacing between keys and values in object literal properties.
         'key-spacing': ['error', {'align': {
             'beforeColon': false,
             'afterColon':  true,

dashboard/assets/components/Common.jsx → dashboard/assets/common.jsx

@@ -63,3 +63,9 @@ export type MenuProp = {|...ProvidedMenuProp, id: string|};
 export const MENU: Map<string, {...MenuProp}> = new Map(menuSkeletons.map(({id, menu}) => ([id, {id, ...menu}])));
 
 export const DURATION = 200;
+
+export const styles = {
+	light: {
+		color: 'rgba(255, 255, 255, 0.54)',
+	},
+}

dashboard/assets/components/Body.jsx

@@ -18,35 +18,32 @@
 
 import React, {Component} from 'react';
 
-import withStyles from 'material-ui/styles/withStyles';
-
 import SideBar from './SideBar';
 import Main from './Main';
 import type {Content} from '../types/content';
 
-// Styles for the Body component.
-const styles = () => ({
+// styles contains the constant styles of the component.
+const styles = {
 	body: {
 		display: 'flex',
 		width:   '100%',
 		height:  '100%',
 	},
-});
+};
+
 export type Props = {
-	classes: Object,
 	opened: boolean,
-	changeContent: () => {},
+	changeContent: string => void,
 	active: string,
 	content: Content,
 	shouldUpdate: Object,
 };
+
 // Body renders the body of the dashboard.
 class Body extends Component<Props> {
 	render() {
-		const {classes} = this.props; // The classes property is injected by withStyles().
-
 		return (
-			<div className={classes.body}>
+			<div style={styles.body}>
 				<SideBar
 					opened={this.props.opened}
 					changeContent={this.props.changeContent}
@@ -61,4 +58,4 @@ class Body extends Component<Props> {
 	}
 }
 
-export default withStyles(styles)(Body);
+export default Body;

dashboard/assets/components/ChartGrid.jsx → dashboard/assets/components/ChartRow.jsx

@@ -1,6 +1,6 @@
 // @flow
 
-// Copyright 2017 The go-ethereum Authors
+// Copyright 2018 The go-ethereum Authors
 // This file is part of the go-ethereum library.
 //
 // The go-ethereum library is free software: you can redistribute it and/or modify
@@ -17,33 +17,41 @@
 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 
 import React, {Component} from 'react';
-import type {Node} from 'react';
+import type {ChildrenArray} from 'react';
 
 import Grid from 'material-ui/Grid';
-import {ResponsiveContainer} from 'recharts';
+
+// styles contains the constant styles of the component.
+const styles = {
+	container: {
+		flexWrap: 'nowrap',
+		height:   '100%',
+		maxWidth: '100%',
+		margin:   0,
+	},
+	item: {
+		flex:    1,
+		padding: 0,
+	},
+}
 
 export type Props = {
-	spacing: number,
-	children: Node,
+	children: ChildrenArray<React$Element<any>>,
 };
-// ChartGrid renders a grid container for responsive charts.
-// The children are Recharts components extended with the Material-UI's xs property.
-class ChartGrid extends Component<Props> {
+
+// ChartRow renders a row of equally sized responsive charts.
+class ChartRow extends Component<Props> {
 	render() {
 		return (
-			<Grid container spacing={this.props.spacing}>
-				{
-					React.Children.map(this.props.children, child => (
-						<Grid item xs={child.props.xs}>
-							<ResponsiveContainer width="100%" height={child.props.height}>
-								{React.cloneElement(child, {data: child.props.values.map(value => ({value}))})}
-							</ResponsiveContainer>
-						</Grid>
-					))
-				}
+			<Grid container direction='row' style={styles.container} justify='space-between'>
+				{React.Children.map(this.props.children, child => (
+					<Grid item xs style={styles.item}>
+						{child}
+					</Grid>
+				))}
 			</Grid>
 		);
 	}
 }
 
-export default ChartGrid;
+export default ChartRow;

dashboard/assets/components/CustomTooltip.jsx

@@ -0,0 +1,95 @@
+// @flow
+
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+import React, {Component} from 'react';
+
+import Typography from 'material-ui/Typography';
+import {styles} from '../common';
+
+// multiplier multiplies a number by another.
+export const multiplier = <T>(by: number = 1) => (x: number) => x * by;
+
+// percentPlotter renders a tooltip, which displays the value of the payload followed by a percent sign.
+export const percentPlotter = <T>(text: string, mapper: (T => T) = multiplier(1)) => (payload: T) => {
+	const p = mapper(payload);
+	if (typeof p !== 'number') {
+		return null;
+	}
+	return (
+		<Typography type='caption' color='inherit'>
+			<span style={styles.light}>{text}</span> {p.toFixed(2)} %
+		</Typography>
+	);
+};
+
+// unit contains the units for the bytePlotter.
+const unit = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'];
+
+// simplifyBytes returns the simplified version of the given value followed by the unit.
+const simplifyBytes = (x: number) => {
+	let i = 0;
+	for (; x > 1024 && i < 5; i++) {
+		x /= 1024;
+	}
+	return x.toFixed(2).toString().concat(' ', unit[i]);
+};
+
+// bytePlotter renders a tooltip, which displays the payload as a byte value.
+export const bytePlotter = <T>(text: string, mapper: (T => T) = multiplier(1)) => (payload: T) => {
+	const p = mapper(payload);
+	if (typeof p !== 'number') {
+		return null;
+	}
+	return (
+		<Typography type='caption' color='inherit'>
+			<span style={styles.light}>{text}</span> {simplifyBytes(p)}
+		</Typography>
+	);
+};
+
+// bytePlotter renders a tooltip, which displays the payload as a byte value followed by '/s'.
+export const bytePerSecPlotter = <T>(text: string, mapper: (T => T) = multiplier(1)) => (payload: T) => {
+	const p = mapper(payload);
+	if (typeof p !== 'number') {
+		return null;
+	}
+	return (
+		<Typography type='caption' color='inherit'>
+			<span style={styles.light}>{text}</span> {simplifyBytes(p)}/s
+		</Typography>
+	);
+};
+
+export type Props = {
+	active: boolean,
+	payload: Object,
+	tooltip: <T>(text: string, mapper?: T => T) => (payload: mixed) => null | React$Element<any>,
+};
+
+// CustomTooltip takes a tooltip function, and uses it to plot the active value of the chart.
+class CustomTooltip extends Component<Props> {
+	render() {
+		const {active, payload, tooltip} = this.props;
+		if (!active || typeof tooltip !== 'function') {
+			return null;
+		}
+		return tooltip(payload[0].value);
+	}
+}
+
+export default CustomTooltip;

dashboard/assets/components/Dashboard.jsx

@@ -22,8 +22,7 @@ import withStyles from 'material-ui/styles/withStyles';
 
 import Header from './Header';
 import Body from './Body';
-import Footer from './Footer';
-import {MENU} from './Common';
+import {MENU} from '../common';
 import type {Content} from '../types/content';
 
 // deepUpdate updates an object corresponding to the given update data, which has
@@ -35,17 +34,17 @@ import type {Content} from '../types/content';
 // the generalization of the message handling. The only necessary thing is to set a
 // handler function for every path of the state in order to maximize the flexibility
 // of the update.
-const deepUpdate = (prev: Object, update: Object, updater: Object) => {
+const deepUpdate = (updater: Object, update: Object, prev: Object): $Shape<Content> => {
 	if (typeof update === 'undefined') {
 		// TODO (kurkomisi): originally this was deep copy, investigate it.
 		return prev;
 	}
 	if (typeof updater === 'function') {
-		return updater(prev, update);
+		return updater(update, prev);
 	}
 	const updated = {};
 	Object.keys(prev).forEach((key) => {
-		updated[key] = deepUpdate(prev[key], update[key], updater[key]);
+		updated[key] = deepUpdate(updater[key], update[key], prev[key]);
 	});
 
 	return updated;
@@ -56,21 +55,25 @@ const deepUpdate = (prev: Object, update: Object, updater: Object) => {
 // whether the involved data was changed or not by checking the message structure.
 //
 // We could return the message itself too, but it's safer not to give access to it.
-const shouldUpdate = (msg: Object, updater: Object) => {
+const shouldUpdate = (updater: Object, msg: Object) => {
 	const su = {};
 	Object.keys(msg).forEach((key) => {
-		su[key] = typeof updater[key] !== 'function' ? shouldUpdate(msg[key], updater[key]) : true;
+		su[key] = typeof updater[key] !== 'function' ? shouldUpdate(updater[key], msg[key]) : true;
 	});
 
 	return su;
 };
 
-// appender is a state update generalization function, which appends the update data
-// to the existing data. limit defines the maximum allowed size of the created array.
-const appender = <T>(limit: number) => (prev: Array<T>, update: Array<T>) => [...prev, ...update].slice(-limit);
+// replacer is a state updater function, which replaces the original data.
+const replacer = <T>(update: T) => update;
 
-// replacer is a state update generalization function, which replaces the original data.
-const replacer = <T>(prev: T, update: T) => update;
+// appender is a state updater function, which appends the update data to the
+// existing data. limit defines the maximum allowed size of the created array,
+// mapper maps the update data.
+const appender = <T>(limit: number, mapper = replacer) => (update: Array<T>, prev: Array<T>) => [
+	...prev,
+	...update.map(sample => mapper(sample)),
+].slice(-limit);
 
 // defaultContent is the initial value of the state content.
 const defaultContent: Content = {
@@ -79,8 +82,14 @@ const defaultContent: Content = {
 		commit:  null,
 	},
 	home: {
-		memory:  [],
-		traffic: [],
+		activeMemory:   [],
+		virtualMemory:  [],
+		networkIngress: [],
+		networkEgress:  [],
+		processCPU:     [],
+		systemCPU:      [],
+		diskRead:       [],
+		diskWrite:      [],
 	},
 	chain:   {},
 	txpool:  {},
@@ -91,16 +100,23 @@ const defaultContent: Content = {
 	},
 };
 
-// updaters contains the state update generalization functions for each path of the state.
-// TODO (kurkomisi): Define a tricky type which embraces the content and the handlers.
+// updaters contains the state updater functions for each path of the state.
+//
+// TODO (kurkomisi): Define a tricky type which embraces the content and the updaters.
 const updaters = {
 	general: {
 		version: replacer,
 		commit:  replacer,
 	},
 	home: {
-		memory:  appender(200),
-		traffic: appender(200),
+		activeMemory:   appender(200),
+		virtualMemory:  appender(200),
+		networkIngress: appender(200),
+		networkEgress:  appender(200),
+		processCPU:     appender(200),
+		systemCPU:      appender(200),
+		diskRead:       appender(200),
+		diskWrite:      appender(200),
 	},
 	chain:   null,
 	txpool:  null,
@@ -111,28 +127,34 @@ const updaters = {
 	},
 };
 
-// styles returns the styles for the Dashboard component.
-const styles = theme => ({
+// styles contains the constant styles of the component.
+const styles = {
+	dashboard: {
+		display:  'flex',
+		flexFlow: 'column',
+		width:    '100%',
+		height:   '100%',
+		zIndex:   1,
+		overflow: 'hidden',
+	}
+};
+
+// themeStyles returns the styles generated from the theme for the component.
+const themeStyles: Object = (theme: Object) => ({
 	dashboard: {
-		display:    'flex',
-		flexFlow:   'column',
-		width:      '100%',
-		height:     '100%',
 		background: theme.palette.background.default,
-		zIndex:     1,
-		overflow:   'hidden',
 	},
 });
 
 export type Props = {
-	classes: Object,
+	classes: Object, // injected by withStyles()
 };
 
 type State = {
 	active: string, // active menu
 	sideBar: boolean, // true if the sidebar is opened
 	content: Content, // the visualized data
-	shouldUpdate: Object // labels for the components, which need to rerender based on the incoming message
+	shouldUpdate: Object, // labels for the components, which need to re-render based on the incoming message
 };
 
 // Dashboard is the main component, which renders the whole page, makes connection with the server and
@@ -176,8 +198,8 @@ class Dashboard extends Component<Props, State> {
 	// update updates the content corresponding to the incoming message.
 	update = (msg: $Shape<Content>) => {
 		this.setState(prevState => ({
-			content:      deepUpdate(prevState.content, msg, updaters),
-			shouldUpdate: shouldUpdate(msg, updaters),
+			content:      deepUpdate(updaters, msg, prevState.content),
+			shouldUpdate: shouldUpdate(updaters, msg),
 		}));
 	};
 
@@ -186,25 +208,17 @@ class Dashboard extends Component<Props, State> {
 		this.setState(prevState => (prevState.active !== newActive ? {active: newActive} : {}));
 	};
 
-	// openSideBar opens the sidebar.
-	openSideBar = () => {
-		this.setState({sideBar: true});
-	};
-
-	// closeSideBar closes the sidebar.
-	closeSideBar = () => {
-		this.setState({sideBar: false});
+	// switchSideBar opens or closes the sidebar's state.
+	switchSideBar = () => {
+		this.setState(prevState => ({sideBar: !prevState.sideBar}));
 	};
 
 	render() {
-		const {classes} = this.props; // The classes property is injected by withStyles().
-
 		return (
-			<div className={classes.dashboard}>
+			<div className={this.props.classes.dashboard} style={styles.dashboard}>
 				<Header
 					opened={this.state.sideBar}
-					openSideBar={this.openSideBar}
-					closeSideBar={this.closeSideBar}
+					switchSideBar={this.switchSideBar}
 				/>
 				<Body
 					opened={this.state.sideBar}
@@ -213,16 +227,9 @@ class Dashboard extends Component<Props, State> {
 					content={this.state.content}
 					shouldUpdate={this.state.shouldUpdate}
 				/>
-				<Footer
-					opened={this.state.sideBar}
-					openSideBar={this.openSideBar}
-					closeSideBar={this.closeSideBar}
-					general={this.state.content.general}
-					shouldUpdate={this.state.shouldUpdate}
-				/>
 			</div>
 		);
 	}
 }
 
-export default withStyles(styles)(Dashboard);
+export default withStyles(themeStyles)(Dashboard);

dashboard/assets/components/Footer.jsx

@@ -19,62 +19,155 @@
 import React, {Component} from 'react';
 
 import withStyles from 'material-ui/styles/withStyles';
-import AppBar from 'material-ui/AppBar';
-import Toolbar from 'material-ui/Toolbar';
 import Typography from 'material-ui/Typography';
+import Grid from 'material-ui/Grid';
+import {ResponsiveContainer, AreaChart, Area, Tooltip} from 'recharts';
 
-import type {General} from '../types/content';
+import ChartRow from './ChartRow';
+import CustomTooltip, {bytePlotter, bytePerSecPlotter, percentPlotter, multiplier} from './CustomTooltip';
+import {styles as commonStyles} from '../common';
+import type {Content} from '../types/content';
 
-// styles contains styles for the Header component.
-const styles = theme => ({
+// styles contains the constant styles of the component.
+const styles = {
+	footer: {
+		maxWidth: '100%',
+		flexWrap: 'nowrap',
+		margin:   0,
+	},
+	chartRowWrapper: {
+		height:  '100%',
+		padding: 0,
+	},
+	doubleChartWrapper: {
+		height:     '100%',
+		width:      '99%',
+		paddingTop: 5,
+	},
+};
+
+// themeStyles returns the styles generated from the theme for the component.
+const themeStyles: Object = (theme: Object) => ({
 	footer: {
 		backgroundColor: theme.palette.background.appBar,
 		color:           theme.palette.getContrastText(theme.palette.background.appBar),
 		zIndex:          theme.zIndex.appBar,
-	},
-	toolbar: {
-		paddingLeft:    theme.spacing.unit,
-		paddingRight:   theme.spacing.unit,
-		display:        'flex',
-		justifyContent: 'flex-end',
-	},
-	light: {
-		color: 'rgba(255, 255, 255, 0.54)',
+		height:          theme.spacing.unit * 10,
 	},
 });
+
 export type Props = {
-	general: General,
-	classes: Object,
+	classes: Object, // injected by withStyles()
+	theme: Object,
+	content: Content,
+	shouldUpdate: Object,
 };
-// TODO (kurkomisi): If the structure is appropriate, make an abstraction of the common parts with the Header.
-// Footer renders the header of the dashboard.
+
+// Footer renders the footer of the dashboard.
 class Footer extends Component<Props> {
 	shouldComponentUpdate(nextProps) {
-		return typeof nextProps.shouldUpdate.logs !== 'undefined';
+		return typeof nextProps.shouldUpdate.home !== 'undefined';
 	}
 
-	info = (about: string, data: string) => (
-		<Typography type="caption" color="inherit">
-			<span className={this.props.classes.light}>{about}</span> {data}
+	// info renders a label with the given values.
+	info = (about: string, value: ?string) => (value ? (
+		<Typography type='caption' color='inherit'>
+			<span style={commonStyles.light}>{about}</span> {value}
 		</Typography>
-	);
+	) : null);
+
+	// doubleChart renders a pair of charts separated by the baseline.
+	doubleChart = (syncId, topChart, bottomChart) => {
+		const topKey = 'topKey';
+		const bottomKey = 'bottomKey';
+		const topDefault = topChart.default ? topChart.default : 0;
+		const bottomDefault = bottomChart.default ? bottomChart.default : 0;
+		const topTooltip = topChart.tooltip ? (
+			<Tooltip cursor={false} content={<CustomTooltip tooltip={topChart.tooltip} />} />
+		) : null;
+		const bottomTooltip = bottomChart.tooltip ? (
+			<Tooltip cursor={false} content={<CustomTooltip tooltip={bottomChart.tooltip} />} />
+		) : null;
+		const topColor = '#8884d8';
+		const bottomColor = '#82ca9d';
+
+		// Put the samples of the two charts into the same array in order to avoid problems
+		// at the synchronized area charts. If one of the two arrays doesn't have value at
+		// a given position, give it a 0 default value.
+		let data = [...topChart.data.map(({value}) => {
+			const d = {};
+			d[topKey] = value || topDefault;
+			return d;
+		})];
+		for (let i = 0; i < data.length && i < bottomChart.data.length; i++) {
+			// The value needs to be negative in order to plot it upside down.
+			const d = bottomChart.data[i];
+			data[i][bottomKey] = d && d.value ? -d.value : bottomDefault;
+		}
+		data = [...data, ...bottomChart.data.slice(data.length).map(({value}) => {
+			const d = {};
+			d[topKey] = topDefault;
+			d[bottomKey] = -value || bottomDefault;
+			return d;
+		})];
+
+		return (
+			<div style={styles.doubleChartWrapper}>
+				<ResponsiveContainer width='100%' height='50%'>
+					<AreaChart data={data} syncId={syncId} >
+						{topTooltip}
+						<Area type='monotone' dataKey={topKey} stroke={topColor} fill={topColor} />
+					</AreaChart>
+				</ResponsiveContainer>
+				<div style={{marginTop: -10, width: '100%', height: '50%'}}>
+					<ResponsiveContainer width='100%' height='100%'>
+						<AreaChart data={data} syncId={syncId} >
+							{bottomTooltip}
+							<Area type='monotone' dataKey={bottomKey} stroke={bottomColor} fill={bottomColor} />
+						</AreaChart>
+					</ResponsiveContainer>
+				</div>
+			</div>
+		);
+	}
 
 	render() {
-		const {classes, general} = this.props; // The classes property is injected by withStyles().
-		const geth = general.version ? this.info('Geth', general.version) : null;
-		const commit = general.commit ? this.info('Commit', general.commit.substring(0, 7)) : null;
+		const {content} = this.props;
+		const {general, home} = content;
 
 		return (
-			<AppBar position="static" className={classes.footer}>
-				<Toolbar className={classes.toolbar}>
-					<div>
-						{geth}
-						{commit}
-					</div>
-				</Toolbar>
-			</AppBar>
+			<Grid container className={this.props.classes.footer} direction='row' alignItems='center' style={styles.footer}>
+				<Grid item xs style={styles.chartRowWrapper}>
+					<ChartRow>
+						{this.doubleChart(
+							'all',
+							{data: home.processCPU, tooltip: percentPlotter('Process')},
+							{data: home.systemCPU, tooltip: percentPlotter('System', multiplier(-1))},
+						)}
+						{this.doubleChart(
+							'all',
+							{data: home.activeMemory, tooltip: bytePlotter('Active')},
+							{data: home.virtualMemory, tooltip: bytePlotter('Virtual', multiplier(-1))},
+						)}
+						{this.doubleChart(
+							'all',
+							{data: home.diskRead, tooltip: bytePerSecPlotter('Disk Read')},
+							{data: home.diskWrite, tooltip: bytePerSecPlotter('Disk Write', multiplier(-1))},
+						)}
+						{this.doubleChart(
+							'all',
+							{data: home.networkIngress, tooltip: bytePerSecPlotter('Download')},
+							{data: home.networkEgress, tooltip: bytePerSecPlotter('Upload', multiplier(-1))},
+						)}
+					</ChartRow>
+				</Grid>
+				<Grid item >
+					{this.info('Geth', general.version)}
+					{this.info('Commit', general.commit ? general.commit.substring(0, 7) : null)}
+				</Grid>
+			</Grid>
 		);
 	}
 }
 
-export default withStyles(styles)(Footer);
+export default withStyles(themeStyles)(Footer);

dashboard/assets/components/Header.jsx

@@ -26,18 +26,22 @@ import IconButton from 'material-ui/IconButton';
 import Typography from 'material-ui/Typography';
 import ChevronLeftIcon from 'material-ui-icons/ChevronLeft';
 
-import {DURATION} from './Common';
+import {DURATION} from '../common';
 
-// arrowDefault is the default style of the arrow button.
-const arrowDefault = {
-	transition: `transform ${DURATION}ms`,
-};
-// arrowTransition is the additional style of the arrow button corresponding to the transition's state.
-const arrowTransition = {
-	entered: {transform: 'rotate(180deg)'},
+// styles contains the constant styles of the component.
+const styles = {
+	arrow: {
+		default: {
+			transition: `transform ${DURATION}ms`,
+		},
+		transition: {
+			entered: {transform: 'rotate(180deg)'},
+		},
+	},
 };
-// Styles for the Header component.
-const styles = theme => ({
+
+// themeStyles returns the styles generated from the theme for the component.
+const themeStyles = (theme: Object) => ({
 	header: {
 		backgroundColor: theme.palette.background.appBar,
 		color:           theme.palette.getContrastText(theme.palette.background.appBar),
@@ -47,53 +51,45 @@ const styles = theme => ({
 		paddingLeft:  theme.spacing.unit,
 		paddingRight: theme.spacing.unit,
 	},
-	mainText: {
+	title: {
 		paddingLeft: theme.spacing.unit,
 	},
 });
+
 export type Props = {
-	classes: Object,
+	classes: Object, // injected by withStyles()
 	opened: boolean,
-	openSideBar: () => {},
-	closeSideBar: () => {},
+	switchSideBar: () => void,
 };
+
 // Header renders the header of the dashboard.
 class Header extends Component<Props> {
 	shouldComponentUpdate(nextProps) {
 		return nextProps.opened !== this.props.opened;
 	}
 
-	// changeSideBar opens or closes the sidebar corresponding to the previous state.
-	changeSideBar = () => {
-		if (this.props.opened) {
-			this.props.closeSideBar();
-		} else {
-			this.props.openSideBar();
-		}
-	};
-
-	// arrowButton is connected to the sidebar; changes its state.
-	arrowButton = (transitionState: string) => (
-		<IconButton onClick={this.changeSideBar}>
+	// arrow renders a button, which changes the sidebar's state.
+	arrow = (transitionState: string) => (
+		<IconButton onClick={this.props.switchSideBar}>
 			<ChevronLeftIcon
 				style={{
-					...arrowDefault,
-					...arrowTransition[transitionState],
+					...styles.arrow.default,
+					...styles.arrow.transition[transitionState],
 				}}
 			/>
 		</IconButton>
 	);
 
 	render() {
-		const {classes, opened} = this.props; // The classes property is injected by withStyles().
+		const {classes, opened} = this.props;
 
 		return (
-			<AppBar position="static" className={classes.header}>
+			<AppBar position='static' className={classes.header}>
 				<Toolbar className={classes.toolbar}>
 					<Transition mountOnEnter in={opened} timeout={{enter: DURATION}}>
-						{this.arrowButton}
+						{this.arrow}
 					</Transition>
-					<Typography type="title" color="inherit" noWrap className={classes.mainText}>
+					<Typography type='title' color='inherit' noWrap className={classes.title}>
 						Go Ethereum Dashboard
 					</Typography>
 				</Toolbar>
@@ -102,4 +98,4 @@ class Header extends Component<Props> {
 	}
 }
 
-export default withStyles(styles)(Header);
+export default withStyles(themeStyles)(Header);

dashboard/assets/components/Home.jsx

@@ -1,77 +0,0 @@
-// @flow
-
-// Copyright 2017 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-import React, {Component} from 'react';
-
-import withTheme from 'material-ui/styles/withTheme';
-import {LineChart, AreaChart, Area, YAxis, CartesianGrid, Line} from 'recharts';
-
-import ChartGrid from './ChartGrid';
-import type {ChartEntry} from '../types/content';
-
-export type Props = {
-    theme: Object,
-    memory: Array<ChartEntry>,
-    traffic: Array<ChartEntry>,
-	shouldUpdate: Object,
-};
-// Home renders the home content.
-class Home extends Component<Props> {
-	constructor(props: Props) {
-		super(props);
-		const {theme} = props; // The theme property is injected by withTheme().
-		this.memoryColor = theme.palette.primary[300];
-		this.trafficColor = theme.palette.secondary[300];
-	}
-
-	shouldComponentUpdate(nextProps) {
-		return typeof nextProps.shouldUpdate.home !== 'undefined';
-	}
-
-	memoryColor: Object;
-	trafficColor: Object;
-
-	render() {
-		let {memory, traffic} = this.props;
-		memory = memory.map(({value}) => (value || 0));
-		traffic = traffic.map(({value}) => (value || 0));
-
-		return (
-			<ChartGrid spacing={24}>
-				<AreaChart xs={6} height={300} values={memory}>
-					<YAxis />
-					<Area type="monotone" dataKey="value" stroke={this.memoryColor} fill={this.memoryColor} />
-				</AreaChart>
-				<LineChart xs={6} height={300} values={traffic}>
-					<Line type="monotone" dataKey="value" stroke={this.trafficColor} dot={false} />
-				</LineChart>
-				<LineChart xs={6} height={300} values={memory}>
-					<YAxis />
-					<CartesianGrid stroke="#eee" strokeDasharray="5 5" />
-					<Line type="monotone" dataKey="value" stroke={this.memoryColor} dot={false} />
-				</LineChart>
-				<AreaChart xs={6} height={300} values={traffic}>
-					<CartesianGrid stroke="#eee" strokeDasharray="5 5" vertical={false} />
-					<Area type="monotone" dataKey="value" stroke={this.trafficColor} fill={this.trafficColor} />
-				</AreaChart>
-			</ChartGrid>
-		);
-	}
-}
-
-export default withTheme()(Home);

dashboard/assets/components/Main.jsx

@@ -20,25 +20,38 @@ import React, {Component} from 'react';
 
 import withStyles from 'material-ui/styles/withStyles';
 
-import Home from './Home';
-import {MENU} from './Common';
+import {MENU} from '../common';
+import Footer from './Footer';
 import type {Content} from '../types/content';
 
-// Styles for the Content component.
-const styles = theme => ({
+// styles contains the constant styles of the component.
+const styles = {
+	wrapper: {
+		display:       'flex',
+		flexDirection: 'column',
+		width:         '100%',
+	},
+	content: {
+		flex:     1,
+		overflow: 'auto',
+	},
+};
+
+// themeStyles returns the styles generated from the theme for the component.
+const themeStyles = theme => ({
 	content: {
-		flexGrow:        1,
 		backgroundColor: theme.palette.background.default,
 		padding:         theme.spacing.unit * 3,
-		overflow:        'auto',
 	},
 });
+
 export type Props = {
 	classes: Object,
 	active: string,
 	content: Content,
 	shouldUpdate: Object,
 };
+
 // Main renders the chosen content.
 class Main extends Component<Props> {
 	render() {
@@ -49,8 +62,6 @@ class Main extends Component<Props> {
 		let children = null;
 		switch (active) {
 		case MENU.get('home').id:
-			children = <Home memory={content.home.memory} traffic={content.home.traffic} shouldUpdate={shouldUpdate} />;
-			break;
 		case MENU.get('chain').id:
 		case MENU.get('txpool').id:
 		case MENU.get('network').id:
@@ -61,8 +72,16 @@ class Main extends Component<Props> {
 			children = <div>{content.logs.log.map((log, index) => <div key={index}>{log}</div>)}</div>;
 		}
 
-		return <div className={classes.content}>{children}</div>;
+		return (
+			<div style={styles.wrapper}>
+				<div className={classes.content} style={styles.content}>{children}</div>
+				<Footer
+					content={content}
+					shouldUpdate={shouldUpdate}
+				/>
+			</div>
+		);
 	}
 }
 
-export default withStyles(styles)(Main);
+export default withStyles(themeStyles)(Main);

dashboard/assets/components/SideBar.jsx

@@ -24,18 +24,22 @@ import Icon from 'material-ui/Icon';
 import Transition from 'react-transition-group/Transition';
 import {Icon as FontAwesome} from 'react-fa';
 
-import {MENU, DURATION} from './Common';
+import {MENU, DURATION} from '../common';
 
-// menuDefault is the default style of the menu.
-const menuDefault = {
-	transition: `margin-left ${DURATION}ms`,
-};
-// menuTransition is the additional style of the menu corresponding to the transition's state.
-const menuTransition = {
-	entered: {marginLeft: -200},
+// styles contains the constant styles of the component.
+const styles = {
+	menu: {
+		default: {
+			transition: `margin-left ${DURATION}ms`,
+		},
+		transition: {
+			entered: {marginLeft: -200},
+		},
+	},
 };
-// Styles for the SideBar component.
-const styles = theme => ({
+
+// themeStyles returns the styles generated from the theme for the component.
+const themeStyles = theme => ({
 	list: {
 		background: theme.palette.background.appBar,
 	},
@@ -46,38 +50,32 @@ const styles = theme => ({
 		fontSize: theme.spacing.unit * 3,
 	},
 });
+
 export type Props = {
-	classes: Object,
+	classes: Object, // injected by withStyles()
 	opened: boolean,
-	changeContent: () => {},
+	changeContent: string => void,
 };
+
 // SideBar renders the sidebar of the dashboard.
 class SideBar extends Component<Props> {
-	constructor(props) {
-		super(props);
-
-		// clickOn contains onClick event functions for the menu items.
-		// Instantiate only once, and reuse the existing functions to prevent the creation of
-		// new function instances every time the render method is triggered.
-		this.clickOn = {};
-		MENU.forEach((menu) => {
-			this.clickOn[menu.id] = (event) => {
-				event.preventDefault();
-				props.changeContent(menu.id);
-			};
-		});
-	}
-
 	shouldComponentUpdate(nextProps) {
 		return nextProps.opened !== this.props.opened;
 	}
 
+	// clickOn returns a click event handler function for the given menu item.
+	clickOn = menu => (event) => {
+		event.preventDefault();
+		this.props.changeContent(menu);
+	};
+
+	// menuItems returns the menu items corresponding to the sidebar state.
 	menuItems = (transitionState) => {
 		const {classes} = this.props;
 		const children = [];
 		MENU.forEach((menu) => {
-			children.push(
-				<ListItem button key={menu.id} onClick={this.clickOn[menu.id]} className={classes.listItem}>
+			children.push((
+				<ListItem button key={menu.id} onClick={this.clickOn(menu.id)} className={classes.listItem}>
 					<ListItemIcon>
 						<Icon className={classes.icon}>
 							<FontAwesome name={menu.icon} />
@@ -86,29 +84,25 @@ class SideBar extends Component<Props> {
 					<ListItemText
 						primary={menu.title}
 						style={{
-							...menuDefault,
-							...menuTransition[transitionState],
+							...styles.menu.default,
+							...styles.menu.transition[transitionState],
 							padding: 0,
 						}}
 					/>
-				</ListItem>,
-			);
+				</ListItem>
+			));
 		});
 		return children;
 	};
 
 	// menu renders the list of the menu items.
-	menu = (transitionState) => {
-		const {classes} = this.props; // The classes property is injected by withStyles().
-
-		return (
-			<div className={classes.list}>
-				<List>
-					{this.menuItems(transitionState)}
-				</List>
-			</div>
-		);
-	};
+	menu = (transitionState: Object) => (
+		<div className={this.props.classes.list}>
+			<List>
+				{this.menuItems(transitionState)}
+			</List>
+		</div>
+	);
 
 	render() {
 		return (
@@ -119,4 +113,4 @@ class SideBar extends Component<Props> {
 	}
 }
 
-export default withStyles(styles)(SideBar);
+export default withStyles(themeStyles)(SideBar);

dashboard/assets/index.jsx

@@ -24,18 +24,18 @@ import createMuiTheme from 'material-ui/styles/createMuiTheme';
 
 import Dashboard from './components/Dashboard';
 
-const theme = createMuiTheme({
-    palette: {
-        type: 'dark',
-    },
+const theme: Object = createMuiTheme({
+	palette: {
+		type: 'dark',
+	},
 });
 const dashboard = document.getElementById('dashboard');
 if (dashboard) {
-    // Renders the whole dashboard.
-    render(
-        <MuiThemeProvider theme={theme}>
-            <Dashboard />
-        </MuiThemeProvider>,
-        dashboard,
-    );
+	// Renders the whole dashboard.
+	render(
+		<MuiThemeProvider theme={theme}>
+			<Dashboard />
+		</MuiThemeProvider>,
+		dashboard,
+	);
 }

dashboard/assets/package.json

@@ -1,7 +1,7 @@
 {
     "dependencies": {
         "babel-core": "^6.26.0",
-        "babel-eslint": "^8.1.2",
+        "babel-eslint": "^8.2.1",
         "babel-loader": "^7.1.2",
         "babel-plugin-transform-class-properties": "^6.24.1",
         "babel-plugin-transform-decorators-legacy": "^1.3.4",
@@ -12,8 +12,8 @@
         "babel-preset-stage-0": "^6.24.1",
         "babel-runtime": "^6.26.0",
         "classnames": "^2.2.5",
-        "css-loader": "^0.28.8",
-        "eslint": "^4.15.0",
+        "css-loader": "^0.28.9",
+        "eslint": "^4.16.0",
         "eslint-config-airbnb": "^16.1.0",
         "eslint-loader": "^1.9.0",
         "eslint-plugin-import": "^2.8.0",
@@ -24,16 +24,15 @@
         "flow-bin": "^0.63.1",
         "flow-bin-loader": "^1.0.2",
         "flow-typed": "^2.2.3",
-        "material-ui": "^1.0.0-beta.24",
+        "material-ui": "^1.0.0-beta.30",
         "material-ui-icons": "^1.0.0-beta.17",
         "path": "^0.12.7",
         "react": "^16.2.0",
         "react-dom": "^16.2.0",
         "react-fa": "^5.0.0",
         "react-transition-group": "^2.2.1",
-        "recharts": "^1.0.0-beta.7",
+        "recharts": "^1.0.0-beta.9",
         "style-loader": "^0.19.1",
-        "typeface-roboto": "^0.0.50",
         "url": "^0.11.0",
         "url-loader": "^0.6.2",
         "webpack": "^3.10.0"

dashboard/assets/types/content.jsx

@@ -32,8 +32,14 @@ export type General = {
 };
 
 export type Home = {
-	memory: ChartEntries,
-	traffic: ChartEntries,
+	activeMemory: ChartEntries,
+	virtualMemory: ChartEntries,
+	networkIngress: ChartEntries,
+	networkEgress: ChartEntries,
+	processCPU: ChartEntries,
+	systemCPU: ChartEntries,
+	diskRead: ChartEntries,
+	diskWrite: ChartEntries,
 };
 
 export type ChartEntries = Array<ChartEntry>;

dashboard/config.go

@@ -22,7 +22,7 @@ import "time"
 var DefaultConfig = Config{
 	Host:    "localhost",
 	Port:    8080,
-	Refresh: 3 * time.Second,
+	Refresh: 5 * time.Second,
 }
 
 // Config contains the configuration parameters of the dashboard.

dashboard/cpu.go

@@ -0,0 +1,35 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+// +build !windows
+
+package dashboard
+
+import (
+	"syscall"
+
+	"github.com/ethereum/go-ethereum/log"
+)
+
+// getProcessCPUTime retrieves the process' CPU time since program startup.
+func getProcessCPUTime() float64 {
+	var usage syscall.Rusage
+	if err := syscall.Getrusage(syscall.RUSAGE_SELF, &usage); err != nil {
+		log.Warn("Failed to retrieve CPU time", "err", err)
+		return 0
+	}
+	return float64(usage.Utime.Sec+usage.Stime.Sec) + float64(usage.Utime.Usec+usage.Stime.Usec)/1000000
+}

dashboard/cpu_windows.go

@@ -0,0 +1,23 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package dashboard
+
+// getProcessCPUTime returns 0 on Windows as there is no system call to resolve
+// the actual process' CPU time.
+func getProcessCPUTime() float64 {
+	return 0
+}

dashboard/dashboard.go

@@ -29,10 +29,12 @@ import (
 	"net"
 	"net/http"
 	"path/filepath"
+	"runtime"
 	"sync"
 	"sync/atomic"
 	"time"
 
+	"github.com/elastic/gosigar"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/p2p"
 	"github.com/ethereum/go-ethereum/params"
@@ -42,8 +44,14 @@ import (
 )
 
 const (
-	memorySampleLimit  = 200 // Maximum number of memory data samples
-	trafficSampleLimit = 200 // Maximum number of traffic data samples
+	activeMemorySampleLimit   = 200 // Maximum number of active memory data samples
+	virtualMemorySampleLimit  = 200 // Maximum number of virtual memory data samples
+	networkIngressSampleLimit = 200 // Maximum number of network ingress data samples
+	networkEgressSampleLimit  = 200 // Maximum number of network egress data samples
+	processCPUSampleLimit     = 200 // Maximum number of process cpu data samples
+	systemCPUSampleLimit      = 200 // Maximum number of system cpu data samples
+	diskReadSampleLimit       = 200 // Maximum number of disk read data samples
+	diskWriteSampleLimit      = 200 // Maximum number of disk write data samples
 )
 
 var nextID uint32 // Next connection id
@@ -71,16 +79,35 @@ type client struct {
 
 // New creates a new dashboard instance with the given configuration.
 func New(config *Config, commit string) (*Dashboard, error) {
-	return &Dashboard{
+	now := time.Now()
+	db := &Dashboard{
 		conns:  make(map[uint32]*client),
 		config: config,
 		quit:   make(chan chan error),
 		charts: &HomeMessage{
-			Memory:  ChartEntries{},
-			Traffic: ChartEntries{},
+			ActiveMemory:   emptyChartEntries(now, activeMemorySampleLimit, config.Refresh),
+			VirtualMemory:  emptyChartEntries(now, virtualMemorySampleLimit, config.Refresh),
+			NetworkIngress: emptyChartEntries(now, networkIngressSampleLimit, config.Refresh),
+			NetworkEgress:  emptyChartEntries(now, networkEgressSampleLimit, config.Refresh),
+			ProcessCPU:     emptyChartEntries(now, processCPUSampleLimit, config.Refresh),
+			SystemCPU:      emptyChartEntries(now, systemCPUSampleLimit, config.Refresh),
+			DiskRead:       emptyChartEntries(now, diskReadSampleLimit, config.Refresh),
+			DiskWrite:      emptyChartEntries(now, diskWriteSampleLimit, config.Refresh),
 		},
 		commit: commit,
-	}, nil
+	}
+	return db, nil
+}
+
+// emptyChartEntries returns a ChartEntry array containing limit number of empty samples.
+func emptyChartEntries(t time.Time, limit int, refresh time.Duration) ChartEntries {
+	ce := make(ChartEntries, limit)
+	for i := 0; i < limit; i++ {
+		ce[i] = &ChartEntry{
+			Time: t.Add(-time.Duration(i) * refresh),
+		}
+	}
+	return ce
 }
 
 // Protocols is a meaningless implementation of node.Service.
@@ -215,8 +242,14 @@ func (db *Dashboard) apiHandler(conn *websocket.Conn) {
 			Commit:  db.commit,
 		},
 		Home: &HomeMessage{
-			Memory:  db.charts.Memory,
-			Traffic: db.charts.Traffic,
+			ActiveMemory:   db.charts.ActiveMemory,
+			VirtualMemory:  db.charts.VirtualMemory,
+			NetworkIngress: db.charts.NetworkIngress,
+			NetworkEgress:  db.charts.NetworkEgress,
+			ProcessCPU:     db.charts.ProcessCPU,
+			SystemCPU:      db.charts.SystemCPU,
+			DiskRead:       db.charts.DiskRead,
+			DiskWrite:      db.charts.DiskWrite,
 		},
 	}
 	// Start tracking the connection and drop at connection loss.
@@ -241,6 +274,19 @@ func (db *Dashboard) apiHandler(conn *websocket.Conn) {
 // collectData collects the required data to plot on the dashboard.
 func (db *Dashboard) collectData() {
 	defer db.wg.Done()
+	systemCPUUsage := gosigar.Cpu{}
+	systemCPUUsage.Get()
+	var (
+		prevNetworkIngress = metrics.DefaultRegistry.Get("p2p/InboundTraffic").(metrics.Meter).Count()
+		prevNetworkEgress  = metrics.DefaultRegistry.Get("p2p/OutboundTraffic").(metrics.Meter).Count()
+		prevProcessCPUTime = getProcessCPUTime()
+		prevSystemCPUUsage = systemCPUUsage
+		prevDiskRead       = metrics.DefaultRegistry.Get("eth/db/chaindata/compact/input").(metrics.Meter).Count()
+		prevDiskWrite      = metrics.DefaultRegistry.Get("eth/db/chaindata/compact/output").(metrics.Meter).Count()
+
+		frequency = float64(db.config.Refresh / time.Second)
+		numCPU    = float64(runtime.NumCPU())
+	)
 
 	for {
 		select {
@@ -248,32 +294,84 @@ func (db *Dashboard) collectData() {
 			errc <- nil
 			return
 		case <-time.After(db.config.Refresh):
-			inboundTraffic := metrics.DefaultRegistry.Get("p2p/InboundTraffic").(metrics.Meter).Rate1()
-			memoryInUse := metrics.DefaultRegistry.Get("system/memory/inuse").(metrics.Meter).Rate1()
+			systemCPUUsage.Get()
+			var (
+				curNetworkIngress = metrics.DefaultRegistry.Get("p2p/InboundTraffic").(metrics.Meter).Count()
+				curNetworkEgress  = metrics.DefaultRegistry.Get("p2p/OutboundTraffic").(metrics.Meter).Count()
+				curProcessCPUTime = getProcessCPUTime()
+				curSystemCPUUsage = systemCPUUsage
+				curDiskRead       = metrics.DefaultRegistry.Get("eth/db/chaindata/compact/input").(metrics.Meter).Count()
+				curDiskWrite      = metrics.DefaultRegistry.Get("eth/db/chaindata/compact/output").(metrics.Meter).Count()
+
+				deltaNetworkIngress = float64(curNetworkIngress - prevNetworkIngress)
+				deltaNetworkEgress  = float64(curNetworkEgress - prevNetworkEgress)
+				deltaProcessCPUTime = curProcessCPUTime - prevProcessCPUTime
+				deltaSystemCPUUsage = systemCPUUsage.Delta(prevSystemCPUUsage)
+				deltaDiskRead       = curDiskRead - prevDiskRead
+				deltaDiskWrite      = curDiskWrite - prevDiskWrite
+			)
+			prevNetworkIngress = curNetworkIngress
+			prevNetworkEgress = curNetworkEgress
+			prevProcessCPUTime = curProcessCPUTime
+			prevSystemCPUUsage = curSystemCPUUsage
+			prevDiskRead = curDiskRead
+			prevDiskWrite = curDiskWrite
+
 			now := time.Now()
-			memory := &ChartEntry{
+
+			var mem runtime.MemStats
+			runtime.ReadMemStats(&mem)
+			activeMemory := &ChartEntry{
 				Time:  now,
-				Value: memoryInUse,
+				Value: float64(mem.Alloc) / frequency,
 			}
-			traffic := &ChartEntry{
+			virtualMemory := &ChartEntry{
 				Time:  now,
-				Value: inboundTraffic,
+				Value: float64(mem.Sys) / frequency,
 			}
-			first := 0
-			if len(db.charts.Memory) == memorySampleLimit {
-				first = 1
+			networkIngress := &ChartEntry{
+				Time:  now,
+				Value: deltaNetworkIngress / frequency,
 			}
-			db.charts.Memory = append(db.charts.Memory[first:], memory)
-			first = 0
-			if len(db.charts.Traffic) == trafficSampleLimit {
-				first = 1
+			networkEgress := &ChartEntry{
+				Time:  now,
+				Value: deltaNetworkEgress / frequency,
+			}
+			processCPU := &ChartEntry{
+				Time:  now,
+				Value: deltaProcessCPUTime / frequency / numCPU * 100,
+			}
+			systemCPU := &ChartEntry{
+				Time:  now,
+				Value: float64(deltaSystemCPUUsage.Sys+deltaSystemCPUUsage.User) / frequency / numCPU,
+			}
+			diskRead := &ChartEntry{
+				Time:  now,
+				Value: float64(deltaDiskRead) / frequency,
+			}
+			diskWrite := &ChartEntry{
+				Time:  now,
+				Value: float64(deltaDiskWrite) / frequency,
 			}
-			db.charts.Traffic = append(db.charts.Traffic[first:], traffic)
+			db.charts.ActiveMemory = append(db.charts.ActiveMemory[1:], activeMemory)
+			db.charts.VirtualMemory = append(db.charts.VirtualMemory[1:], virtualMemory)
+			db.charts.NetworkIngress = append(db.charts.NetworkIngress[1:], networkIngress)
+			db.charts.NetworkEgress = append(db.charts.NetworkEgress[1:], networkEgress)
+			db.charts.ProcessCPU = append(db.charts.ProcessCPU[1:], processCPU)
+			db.charts.SystemCPU = append(db.charts.SystemCPU[1:], systemCPU)
+			db.charts.DiskRead = append(db.charts.DiskRead[1:], diskRead)
+			db.charts.DiskWrite = append(db.charts.DiskRead[1:], diskWrite)
 
 			db.sendToAll(&Message{
 				Home: &HomeMessage{
-					Memory:  ChartEntries{memory},
-					Traffic: ChartEntries{traffic},
+					ActiveMemory:   ChartEntries{activeMemory},
+					VirtualMemory:  ChartEntries{virtualMemory},
+					NetworkIngress: ChartEntries{networkIngress},
+					NetworkEgress:  ChartEntries{networkEgress},
+					ProcessCPU:     ChartEntries{processCPU},
+					SystemCPU:      ChartEntries{systemCPU},
+					DiskRead:       ChartEntries{diskRead},
+					DiskWrite:      ChartEntries{diskWrite},
 				},
 			})
 		}

dashboard/message.go

@@ -34,8 +34,14 @@ type GeneralMessage struct {
 }
 
 type HomeMessage struct {
-	Memory  ChartEntries `json:"memory,omitempty"`
-	Traffic ChartEntries `json:"traffic,omitempty"`
+	ActiveMemory   ChartEntries `json:"activeMemory,omitempty"`
+	VirtualMemory  ChartEntries `json:"virtualMemory,omitempty"`
+	NetworkIngress ChartEntries `json:"networkIngress,omitempty"`
+	NetworkEgress  ChartEntries `json:"networkEgress,omitempty"`
+	ProcessCPU     ChartEntries `json:"processCPU,omitempty"`
+	SystemCPU      ChartEntries `json:"systemCPU,omitempty"`
+	DiskRead       ChartEntries `json:"diskRead,omitempty"`
+	DiskWrite      ChartEntries `json:"diskWrite,omitempty"`
 }
 
 type ChartEntries []*ChartEntry

vendor/github.com/StackExchange/wmi/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Stack Exchange
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/github.com/StackExchange/wmi/README.md

@@ -0,0 +1,6 @@
+wmi
+===
+
+Package wmi provides a WQL interface to Windows WMI.
+
+Note: It interfaces with WMI on the local machine, therefore it only runs on Windows.

vendor/github.com/StackExchange/wmi/swbemservices.go

@@ -0,0 +1,260 @@
+// +build windows
+
+package wmi
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"sync"
+
+	"github.com/go-ole/go-ole"
+	"github.com/go-ole/go-ole/oleutil"
+)
+
+// SWbemServices is used to access wmi. See https://msdn.microsoft.com/en-us/library/aa393719(v=vs.85).aspx
+type SWbemServices struct {
+	//TODO: track namespace. Not sure if we can re connect to a different namespace using the same instance
+	cWMIClient            *Client //This could also be an embedded struct, but then we would need to branch on Client vs SWbemServices in the Query method
+	sWbemLocatorIUnknown  *ole.IUnknown
+	sWbemLocatorIDispatch *ole.IDispatch
+	queries               chan *queryRequest
+	closeError            chan error
+	lQueryorClose         sync.Mutex
+}
+
+type queryRequest struct {
+	query    string
+	dst      interface{}
+	args     []interface{}
+	finished chan error
+}
+
+// InitializeSWbemServices will return a new SWbemServices object that can be used to query WMI
+func InitializeSWbemServices(c *Client, connectServerArgs ...interface{}) (*SWbemServices, error) {
+	//fmt.Println("InitializeSWbemServices: Starting")
+	//TODO: implement connectServerArgs as optional argument for init with connectServer call
+	s := new(SWbemServices)
+	s.cWMIClient = c
+	s.queries = make(chan *queryRequest)
+	initError := make(chan error)
+	go s.process(initError)
+
+	err, ok := <-initError
+	if ok {
+		return nil, err //Send error to caller
+	}
+	//fmt.Println("InitializeSWbemServices: Finished")
+	return s, nil
+}
+
+// Close will clear and release all of the SWbemServices resources
+func (s *SWbemServices) Close() error {
+	s.lQueryorClose.Lock()
+	if s == nil || s.sWbemLocatorIDispatch == nil {
+		s.lQueryorClose.Unlock()
+		return fmt.Errorf("SWbemServices is not Initialized")
+	}
+	if s.queries == nil {
+		s.lQueryorClose.Unlock()
+		return fmt.Errorf("SWbemServices has been closed")
+	}
+	//fmt.Println("Close: sending close request")
+	var result error
+	ce := make(chan error)
+	s.closeError = ce //Race condition if multiple callers to close. May need to lock here
+	close(s.queries)  //Tell background to shut things down
+	s.lQueryorClose.Unlock()
+	err, ok := <-ce
+	if ok {
+		result = err
+	}
+	//fmt.Println("Close: finished")
+	return result
+}
+
+func (s *SWbemServices) process(initError chan error) {
+	//fmt.Println("process: starting background thread initialization")
+	//All OLE/WMI calls must happen on the same initialized thead, so lock this goroutine
+	runtime.LockOSThread()
+	defer runtime.LockOSThread()
+
+	err := ole.CoInitializeEx(0, ole.COINIT_MULTITHREADED)
+	if err != nil {
+		oleCode := err.(*ole.OleError).Code()
+		if oleCode != ole.S_OK && oleCode != S_FALSE {
+			initError <- fmt.Errorf("ole.CoInitializeEx error: %v", err)
+			return
+		}
+	}
+	defer ole.CoUninitialize()
+
+	unknown, err := oleutil.CreateObject("WbemScripting.SWbemLocator")
+	if err != nil {
+		initError <- fmt.Errorf("CreateObject SWbemLocator error: %v", err)
+		return
+	} else if unknown == nil {
+		initError <- ErrNilCreateObject
+		return
+	}
+	defer unknown.Release()
+	s.sWbemLocatorIUnknown = unknown
+
+	dispatch, err := s.sWbemLocatorIUnknown.QueryInterface(ole.IID_IDispatch)
+	if err != nil {
+		initError <- fmt.Errorf("SWbemLocator QueryInterface error: %v", err)
+		return
+	}
+	defer dispatch.Release()
+	s.sWbemLocatorIDispatch = dispatch
+
+	// we can't do the ConnectServer call outside the loop unless we find a way to track and re-init the connectServerArgs
+	//fmt.Println("process: initialized. closing initError")
+	close(initError)
+	//fmt.Println("process: waiting for queries")
+	for q := range s.queries {
+		//fmt.Printf("process: new query: len(query)=%d\n", len(q.query))
+		errQuery := s.queryBackground(q)
+		//fmt.Println("process: s.queryBackground finished")
+		if errQuery != nil {
+			q.finished <- errQuery
+		}
+		close(q.finished)
+	}
+	//fmt.Println("process: queries channel closed")
+	s.queries = nil //set channel to nil so we know it is closed
+	//TODO: I think the Release/Clear calls can panic if things are in a bad state.
+	//TODO: May need to recover from panics and send error to method caller instead.
+	close(s.closeError)
+}
+
+// Query runs the WQL query using a SWbemServices instance and appends the values to dst.
+//
+// dst must have type *[]S or *[]*S, for some struct type S. Fields selected in
+// the query must have the same name in dst. Supported types are all signed and
+// unsigned integers, time.Time, string, bool, or a pointer to one of those.
+// Array types are not supported.
+//
+// By default, the local machine and default namespace are used. These can be
+// changed using connectServerArgs. See
+// http://msdn.microsoft.com/en-us/library/aa393720.aspx for details.
+func (s *SWbemServices) Query(query string, dst interface{}, connectServerArgs ...interface{}) error {
+	s.lQueryorClose.Lock()
+	if s == nil || s.sWbemLocatorIDispatch == nil {
+		s.lQueryorClose.Unlock()
+		return fmt.Errorf("SWbemServices is not Initialized")
+	}
+	if s.queries == nil {
+		s.lQueryorClose.Unlock()
+		return fmt.Errorf("SWbemServices has been closed")
+	}
+
+	//fmt.Println("Query: Sending query request")
+	qr := queryRequest{
+		query:    query,
+		dst:      dst,
+		args:     connectServerArgs,
+		finished: make(chan error),
+	}
+	s.queries <- &qr
+	s.lQueryorClose.Unlock()
+	err, ok := <-qr.finished
+	if ok {
+		//fmt.Println("Query: Finished with error")
+		return err //Send error to caller
+	}
+	//fmt.Println("Query: Finished")
+	return nil
+}
+
+func (s *SWbemServices) queryBackground(q *queryRequest) error {
+	if s == nil || s.sWbemLocatorIDispatch == nil {
+		return fmt.Errorf("SWbemServices is not Initialized")
+	}
+	wmi := s.sWbemLocatorIDispatch //Should just rename in the code, but this will help as we break things apart
+	//fmt.Println("queryBackground: Starting")
+
+	dv := reflect.ValueOf(q.dst)
+	if dv.Kind() != reflect.Ptr || dv.IsNil() {
+		return ErrInvalidEntityType
+	}
+	dv = dv.Elem()
+	mat, elemType := checkMultiArg(dv)
+	if mat == multiArgTypeInvalid {
+		return ErrInvalidEntityType
+	}
+
+	// service is a SWbemServices
+	serviceRaw, err := oleutil.CallMethod(wmi, "ConnectServer", q.args...)
+	if err != nil {
+		return err
+	}
+	service := serviceRaw.ToIDispatch()
+	defer serviceRaw.Clear()
+
+	// result is a SWBemObjectSet
+	resultRaw, err := oleutil.CallMethod(service, "ExecQuery", q.query)
+	if err != nil {
+		return err
+	}
+	result := resultRaw.ToIDispatch()
+	defer resultRaw.Clear()
+
+	count, err := oleInt64(result, "Count")
+	if err != nil {
+		return err
+	}
+
+	enumProperty, err := result.GetProperty("_NewEnum")
+	if err != nil {
+		return err
+	}
+	defer enumProperty.Clear()
+
+	enum, err := enumProperty.ToIUnknown().IEnumVARIANT(ole.IID_IEnumVariant)
+	if err != nil {
+		return err
+	}
+	if enum == nil {
+		return fmt.Errorf("can't get IEnumVARIANT, enum is nil")
+	}
+	defer enum.Release()
+
+	// Initialize a slice with Count capacity
+	dv.Set(reflect.MakeSlice(dv.Type(), 0, int(count)))
+
+	var errFieldMismatch error
+	for itemRaw, length, err := enum.Next(1); length > 0; itemRaw, length, err = enum.Next(1) {
+		if err != nil {
+			return err
+		}
+
+		err := func() error {
+			// item is a SWbemObject, but really a Win32_Process
+			item := itemRaw.ToIDispatch()
+			defer item.Release()
+
+			ev := reflect.New(elemType)
+			if err = s.cWMIClient.loadEntity(ev.Interface(), item); err != nil {
+				if _, ok := err.(*ErrFieldMismatch); ok {
+					// We continue loading entities even in the face of field mismatch errors.
+					// If we encounter any other error, that other error is returned. Otherwise,
+					// an ErrFieldMismatch is returned.
+					errFieldMismatch = err
+				} else {
+					return err
+				}
+			}
+			if mat != multiArgTypeStructPtr {
+				ev = ev.Elem()
+			}
+			dv.Set(reflect.Append(dv, ev))
+			return nil
+		}()
+		if err != nil {
+			return err
+		}
+	}
+	//fmt.Println("queryBackground: Finished")
+	return errFieldMismatch
+}

vendor/github.com/StackExchange/wmi/wmi.go

@@ -0,0 +1,486 @@
+// +build windows
+
+/*
+Package wmi provides a WQL interface for WMI on Windows.
+
+Example code to print names of running processes:
+
+	type Win32_Process struct {
+		Name string
+	}
+
+	func main() {
+		var dst []Win32_Process
+		q := wmi.CreateQuery(&dst, "")
+		err := wmi.Query(q, &dst)
+		if err != nil {
+			log.Fatal(err)
+		}
+		for i, v := range dst {
+			println(i, v.Name)
+		}
+	}
+
+*/
+package wmi
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"log"
+	"os"
+	"reflect"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/go-ole/go-ole"
+	"github.com/go-ole/go-ole/oleutil"
+)
+
+var l = log.New(os.Stdout, "", log.LstdFlags)
+
+var (
+	ErrInvalidEntityType = errors.New("wmi: invalid entity type")
+	// ErrNilCreateObject is the error returned if CreateObject returns nil even
+	// if the error was nil.
+	ErrNilCreateObject = errors.New("wmi: create object returned nil")
+	lock               sync.Mutex
+)
+
+// S_FALSE is returned by CoInitializeEx if it was already called on this thread.
+const S_FALSE = 0x00000001
+
+// QueryNamespace invokes Query with the given namespace on the local machine.
+func QueryNamespace(query string, dst interface{}, namespace string) error {
+	return Query(query, dst, nil, namespace)
+}
+
+// Query runs the WQL query and appends the values to dst.
+//
+// dst must have type *[]S or *[]*S, for some struct type S. Fields selected in
+// the query must have the same name in dst. Supported types are all signed and
+// unsigned integers, time.Time, string, bool, or a pointer to one of those.
+// Array types are not supported.
+//
+// By default, the local machine and default namespace are used. These can be
+// changed using connectServerArgs. See
+// http://msdn.microsoft.com/en-us/library/aa393720.aspx for details.
+//
+// Query is a wrapper around DefaultClient.Query.
+func Query(query string, dst interface{}, connectServerArgs ...interface{}) error {
+	if DefaultClient.SWbemServicesClient == nil {
+		return DefaultClient.Query(query, dst, connectServerArgs...)
+	}
+	return DefaultClient.SWbemServicesClient.Query(query, dst, connectServerArgs...)
+}
+
+// A Client is an WMI query client.
+//
+// Its zero value (DefaultClient) is a usable client.
+type Client struct {
+	// NonePtrZero specifies if nil values for fields which aren't pointers
+	// should be returned as the field types zero value.
+	//
+	// Setting this to true allows stucts without pointer fields to be used
+	// without the risk failure should a nil value returned from WMI.
+	NonePtrZero bool
+
+	// PtrNil specifies if nil values for pointer fields should be returned
+	// as nil.
+	//
+	// Setting this to true will set pointer fields to nil where WMI
+	// returned nil, otherwise the types zero value will be returned.
+	PtrNil bool
+
+	// AllowMissingFields specifies that struct fields not present in the
+	// query result should not result in an error.
+	//
+	// Setting this to true allows custom queries to be used with full
+	// struct definitions instead of having to define multiple structs.
+	AllowMissingFields bool
+
+	// SWbemServiceClient is an optional SWbemServices object that can be
+	// initialized and then reused across multiple queries. If it is null
+	// then the method will initialize a new temporary client each time.
+	SWbemServicesClient *SWbemServices
+}
+
+// DefaultClient is the default Client and is used by Query, QueryNamespace
+var DefaultClient = &Client{}
+
+// Query runs the WQL query and appends the values to dst.
+//
+// dst must have type *[]S or *[]*S, for some struct type S. Fields selected in
+// the query must have the same name in dst. Supported types are all signed and
+// unsigned integers, time.Time, string, bool, or a pointer to one of those.
+// Array types are not supported.
+//
+// By default, the local machine and default namespace are used. These can be
+// changed using connectServerArgs. See
+// http://msdn.microsoft.com/en-us/library/aa393720.aspx for details.
+func (c *Client) Query(query string, dst interface{}, connectServerArgs ...interface{}) error {
+	dv := reflect.ValueOf(dst)
+	if dv.Kind() != reflect.Ptr || dv.IsNil() {
+		return ErrInvalidEntityType
+	}
+	dv = dv.Elem()
+	mat, elemType := checkMultiArg(dv)
+	if mat == multiArgTypeInvalid {
+		return ErrInvalidEntityType
+	}
+
+	lock.Lock()
+	defer lock.Unlock()
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	err := ole.CoInitializeEx(0, ole.COINIT_MULTITHREADED)
+	if err != nil {
+		oleCode := err.(*ole.OleError).Code()
+		if oleCode != ole.S_OK && oleCode != S_FALSE {
+			return err
+		}
+	}
+	defer ole.CoUninitialize()
+
+	unknown, err := oleutil.CreateObject("WbemScripting.SWbemLocator")
+	if err != nil {
+		return err
+	} else if unknown == nil {
+		return ErrNilCreateObject
+	}
+	defer unknown.Release()
+
+	wmi, err := unknown.QueryInterface(ole.IID_IDispatch)
+	if err != nil {
+		return err
+	}
+	defer wmi.Release()
+
+	// service is a SWbemServices
+	serviceRaw, err := oleutil.CallMethod(wmi, "ConnectServer", connectServerArgs...)
+	if err != nil {
+		return err
+	}
+	service := serviceRaw.ToIDispatch()
+	defer serviceRaw.Clear()
+
+	// result is a SWBemObjectSet
+	resultRaw, err := oleutil.CallMethod(service, "ExecQuery", query)
+	if err != nil {
+		return err
+	}
+	result := resultRaw.ToIDispatch()
+	defer resultRaw.Clear()
+
+	count, err := oleInt64(result, "Count")
+	if err != nil {
+		return err
+	}
+
+	enumProperty, err := result.GetProperty("_NewEnum")
+	if err != nil {
+		return err
+	}
+	defer enumProperty.Clear()
+
+	enum, err := enumProperty.ToIUnknown().IEnumVARIANT(ole.IID_IEnumVariant)
+	if err != nil {
+		return err
+	}
+	if enum == nil {
+		return fmt.Errorf("can't get IEnumVARIANT, enum is nil")
+	}
+	defer enum.Release()
+
+	// Initialize a slice with Count capacity
+	dv.Set(reflect.MakeSlice(dv.Type(), 0, int(count)))
+
+	var errFieldMismatch error
+	for itemRaw, length, err := enum.Next(1); length > 0; itemRaw, length, err = enum.Next(1) {
+		if err != nil {
+			return err
+		}
+
+		err := func() error {
+			// item is a SWbemObject, but really a Win32_Process
+			item := itemRaw.ToIDispatch()
+			defer item.Release()
+
+			ev := reflect.New(elemType)
+			if err = c.loadEntity(ev.Interface(), item); err != nil {
+				if _, ok := err.(*ErrFieldMismatch); ok {
+					// We continue loading entities even in the face of field mismatch errors.
+					// If we encounter any other error, that other error is returned. Otherwise,
+					// an ErrFieldMismatch is returned.
+					errFieldMismatch = err
+				} else {
+					return err
+				}
+			}
+			if mat != multiArgTypeStructPtr {
+				ev = ev.Elem()
+			}
+			dv.Set(reflect.Append(dv, ev))
+			return nil
+		}()
+		if err != nil {
+			return err
+		}
+	}
+	return errFieldMismatch
+}
+
+// ErrFieldMismatch is returned when a field is to be loaded into a different
+// type than the one it was stored from, or when a field is missing or
+// unexported in the destination struct.
+// StructType is the type of the struct pointed to by the destination argument.
+type ErrFieldMismatch struct {
+	StructType reflect.Type
+	FieldName  string
+	Reason     string
+}
+
+func (e *ErrFieldMismatch) Error() string {
+	return fmt.Sprintf("wmi: cannot load field %q into a %q: %s",
+		e.FieldName, e.StructType, e.Reason)
+}
+
+var timeType = reflect.TypeOf(time.Time{})
+
+// loadEntity loads a SWbemObject into a struct pointer.
+func (c *Client) loadEntity(dst interface{}, src *ole.IDispatch) (errFieldMismatch error) {
+	v := reflect.ValueOf(dst).Elem()
+	for i := 0; i < v.NumField(); i++ {
+		f := v.Field(i)
+		of := f
+		isPtr := f.Kind() == reflect.Ptr
+		if isPtr {
+			ptr := reflect.New(f.Type().Elem())
+			f.Set(ptr)
+			f = f.Elem()
+		}
+		n := v.Type().Field(i).Name
+		if !f.CanSet() {
+			return &ErrFieldMismatch{
+				StructType: of.Type(),
+				FieldName:  n,
+				Reason:     "CanSet() is false",
+			}
+		}
+		prop, err := oleutil.GetProperty(src, n)
+		if err != nil {
+			if !c.AllowMissingFields {
+				errFieldMismatch = &ErrFieldMismatch{
+					StructType: of.Type(),
+					FieldName:  n,
+					Reason:     "no such struct field",
+				}
+			}
+			continue
+		}
+		defer prop.Clear()
+
+		switch val := prop.Value().(type) {
+		case int8, int16, int32, int64, int:
+			v := reflect.ValueOf(val).Int()
+			switch f.Kind() {
+			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+				f.SetInt(v)
+			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+				f.SetUint(uint64(v))
+			default:
+				return &ErrFieldMismatch{
+					StructType: of.Type(),
+					FieldName:  n,
+					Reason:     "not an integer class",
+				}
+			}
+		case uint8, uint16, uint32, uint64:
+			v := reflect.ValueOf(val).Uint()
+			switch f.Kind() {
+			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+				f.SetInt(int64(v))
+			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+				f.SetUint(v)
+			default:
+				return &ErrFieldMismatch{
+					StructType: of.Type(),
+					FieldName:  n,
+					Reason:     "not an integer class",
+				}
+			}
+		case string:
+			switch f.Kind() {
+			case reflect.String:
+				f.SetString(val)
+			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+				iv, err := strconv.ParseInt(val, 10, 64)
+				if err != nil {
+					return err
+				}
+				f.SetInt(iv)
+			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+				uv, err := strconv.ParseUint(val, 10, 64)
+				if err != nil {
+					return err
+				}
+				f.SetUint(uv)
+			case reflect.Struct:
+				switch f.Type() {
+				case timeType:
+					if len(val) == 25 {
+						mins, err := strconv.Atoi(val[22:])
+						if err != nil {
+							return err
+						}
+						val = val[:22] + fmt.Sprintf("%02d%02d", mins/60, mins%60)
+					}
+					t, err := time.Parse("20060102150405.000000-0700", val)
+					if err != nil {
+						return err
+					}
+					f.Set(reflect.ValueOf(t))
+				}
+			}
+		case bool:
+			switch f.Kind() {
+			case reflect.Bool:
+				f.SetBool(val)
+			default:
+				return &ErrFieldMismatch{
+					StructType: of.Type(),
+					FieldName:  n,
+					Reason:     "not a bool",
+				}
+			}
+		case float32:
+			switch f.Kind() {
+			case reflect.Float32:
+				f.SetFloat(float64(val))
+			default:
+				return &ErrFieldMismatch{
+					StructType: of.Type(),
+					FieldName:  n,
+					Reason:     "not a Float32",
+				}
+			}
+		default:
+			if f.Kind() == reflect.Slice {
+				switch f.Type().Elem().Kind() {
+				case reflect.String:
+					safeArray := prop.ToArray()
+					if safeArray != nil {
+						arr := safeArray.ToValueArray()
+						fArr := reflect.MakeSlice(f.Type(), len(arr), len(arr))
+						for i, v := range arr {
+							s := fArr.Index(i)
+							s.SetString(v.(string))
+						}
+						f.Set(fArr)
+					}
+				case reflect.Uint8:
+					safeArray := prop.ToArray()
+					if safeArray != nil {
+						arr := safeArray.ToValueArray()
+						fArr := reflect.MakeSlice(f.Type(), len(arr), len(arr))
+						for i, v := range arr {
+							s := fArr.Index(i)
+							s.SetUint(reflect.ValueOf(v).Uint())
+						}
+						f.Set(fArr)
+					}
+				default:
+					return &ErrFieldMismatch{
+						StructType: of.Type(),
+						FieldName:  n,
+						Reason:     fmt.Sprintf("unsupported slice type (%T)", val),
+					}
+				}
+			} else {
+				typeof := reflect.TypeOf(val)
+				if typeof == nil && (isPtr || c.NonePtrZero) {
+					if (isPtr && c.PtrNil) || (!isPtr && c.NonePtrZero) {
+						of.Set(reflect.Zero(of.Type()))
+					}
+					break
+				}
+				return &ErrFieldMismatch{
+					StructType: of.Type(),
+					FieldName:  n,
+					Reason:     fmt.Sprintf("unsupported type (%T)", val),
+				}
+			}
+		}
+	}
+	return errFieldMismatch
+}
+
+type multiArgType int
+
+const (
+	multiArgTypeInvalid multiArgType = iota
+	multiArgTypeStruct
+	multiArgTypeStructPtr
+)
+
+// checkMultiArg checks that v has type []S, []*S for some struct type S.
+//
+// It returns what category the slice's elements are, and the reflect.Type
+// that represents S.
+func checkMultiArg(v reflect.Value) (m multiArgType, elemType reflect.Type) {
+	if v.Kind() != reflect.Slice {
+		return multiArgTypeInvalid, nil
+	}
+	elemType = v.Type().Elem()
+	switch elemType.Kind() {
+	case reflect.Struct:
+		return multiArgTypeStruct, elemType
+	case reflect.Ptr:
+		elemType = elemType.Elem()
+		if elemType.Kind() == reflect.Struct {
+			return multiArgTypeStructPtr, elemType
+		}
+	}
+	return multiArgTypeInvalid, nil
+}
+
+func oleInt64(item *ole.IDispatch, prop string) (int64, error) {
+	v, err := oleutil.GetProperty(item, prop)
+	if err != nil {
+		return 0, err
+	}
+	defer v.Clear()
+
+	i := int64(v.Val)
+	return i, nil
+}
+
+// CreateQuery returns a WQL query string that queries all columns of src. where
+// is an optional string that is appended to the query, to be used with WHERE
+// clauses. In such a case, the "WHERE" string should appear at the beginning.
+func CreateQuery(src interface{}, where string) string {
+	var b bytes.Buffer
+	b.WriteString("SELECT ")
+	s := reflect.Indirect(reflect.ValueOf(src))
+	t := s.Type()
+	if s.Kind() == reflect.Slice {
+		t = t.Elem()
+	}
+	if t.Kind() != reflect.Struct {
+		return ""
+	}
+	var fields []string
+	for i := 0; i < t.NumField(); i++ {
+		fields = append(fields, t.Field(i).Name)
+	}
+	b.WriteString(strings.Join(fields, ", "))
+	b.WriteString(" FROM ")
+	b.WriteString(t.Name())
+	b.WriteString(" " + where)
+	return b.String()
+}

vendor/github.com/elastic/gosigar/CHANGELOG.md

@@ -0,0 +1,102 @@
+# Change Log
+All notable changes to this project will be documented in this file.
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+## [Unreleased]
+
+### Added
+
+### Fixed
+
+### Changed
+
+### Deprecated
+
+## [0.8.0]
+
+### Added
+- Added partial `getrusage` support for Windows to retrieve system CPU time and user CPU time. #95
+- Added full `getrusage` support for Unix. #95
+
+## [0.7.0]
+
+### Added
+- Added method stubs for process handling for operating system that are not supported
+  by gosigar. All methods return `ErrNotImplemented` on such systems. #88
+
+### Fixed
+- Fix freebsd build by using the common version of Get(pid). #91
+
+### Changed
+- Fixed issues in cgroup package by adding missing error checks and closing
+  file handles. #92
+
+## [0.6.0]
+
+### Added
+- Added method stubs to enable compilation for operating systems that are not
+  supported by gosigar. All methods return `ErrNotImplemented` on these unsupported
+  operating systems. #83
+- FreeBSD returns `ErrNotImplemented` for `ProcTime.Get`. #83
+
+### Changed
+- OpenBSD returns `ErrNotImplemented` for `ProcTime.Get` instead of `nil`. #83
+- Fixed incorrect `Mem.Used` calculation under linux. #82
+- Fixed `ProcState` on Linux and FreeBSD when process names contain parentheses. #81
+
+### Removed
+- Remove NetBSD build from sigar_unix.go as it is not supported by gosigar. #83
+
+## [0.5.0]
+
+### Changed
+- Fixed Trim environment variables when comparing values in the test suite. #79
+- Make `kern_procargs` more robust under darwin when we cannot retrieve
+  all the information about a process. #78
+
+## [0.4.0]
+
+### Changed
+- Fixed Windows issue that caused a hang during `init()` if WMI wasn't ready. #74
+
+## [0.3.0]
+
+### Added
+- Read `MemAvailable` value for kernel 3.14+ #71
+
+## [0.2.0]
+
+### Added
+- Added `ErrCgroupsMissing` to indicate that /proc/cgroups is missing which is
+  an indicator that cgroups were disabled at compile time. #64
+
+### Changed
+- Changed `cgroup.SupportedSubsystems()` to honor the "enabled" column in the
+  /proc/cgroups file. #64
+
+## [0.1.0]
+
+### Added
+- Added `CpuList` implementation for Windows that returns CPU timing information
+  on a per CPU basis. #55
+- Added `Uptime` implementation for Windows. #55
+- Added `Swap` implementation for Windows based on page file metrics. #55
+- Added support to `github.com/gosigar/sys/windows` for querying and enabling
+  privileges in a process token.
+- Added utility code for interfacing with linux NETLINK_INET_DIAG. #60
+- Added `ProcEnv` for getting a process's environment variables. #61
+
+### Changed
+- Changed several `OpenProcess` calls on Windows to request the lowest possible
+  access privileges. #50
+- Removed cgo usage from Windows code.
+- Added OS version checks to `ProcArgs.Get` on Windows because the
+  `Win32_Process` WMI query is not available prior to Windows vista. On XP and
+  Windows 2003, this method returns `ErrNotImplemented`. #55
+
+### Fixed
+- Fixed value of `Mem.ActualFree` and `Mem.ActualUsed` on Windows. #49
+- Fixed `ProcTime.StartTime` on Windows to report value in milliseconds since
+  Unix epoch. #51
+- Fixed `ProcStatus.PPID` value is wrong on Windows. #55
+- Fixed `ProcStatus.Username` error on Windows XP #56

vendor/github.com/elastic/gosigar/LICENSE

@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

vendor/github.com/elastic/gosigar/NOTICE

@@ -0,0 +1,9 @@
+Copyright (c) [2009-2011] VMware, Inc. All Rights Reserved. 
+
+This product is licensed to you under the Apache License, Version 2.0 (the "License").  
+You may not use this product except in compliance with the License.  
+
+This product includes a number of subcomponents with
+separate copyright notices and license terms. Your use of these
+subcomponents is subject to the terms and conditions of the 
+subcomponent's license, as noted in the LICENSE file.

vendor/github.com/elastic/gosigar/README.md

@@ -0,0 +1,57 @@
+# Go sigar [![Build Status](https://travis-ci.org/elastic/gosigar.svg?branch=master)](https://travis-ci.org/elastic/gosigar) [![Build status](https://ci.appveyor.com/api/projects/status/4yh6sa7u97ek5uib/branch/master?svg=true)](https://ci.appveyor.com/project/elastic-beats/gosigar/branch/master)
+
+
+## Overview
+
+Go sigar is a golang implementation of the
+[sigar API](https://github.com/hyperic/sigar).  The Go version of
+sigar has a very similar interface, but is being written from scratch
+in pure go/cgo, rather than cgo bindings for libsigar.
+
+## Test drive
+
+    $ go get github.com/elastic/gosigar
+    $ cd $GOPATH/src/github.com/elastic/gosigar/examples/ps
+    $ go build
+    $ ./ps
+
+## Supported platforms
+
+The features vary by operating system.
+
+| Feature         | Linux | Darwin | Windows | OpenBSD | FreeBSD |
+|-----------------|:-----:|:------:|:-------:|:-------:|:-------:|
+| Cpu             |   X   |    X   |    X    |    X    |    X    |
+| CpuList         |   X   |    X   |         |    X    |    X    |
+| FDUsage         |   X   |        |         |         |    X    |
+| FileSystemList  |   X   |    X   |    X    |    X    |    X    |
+| FileSystemUsage |   X   |    X   |    X    |    X    |    X    |
+| LoadAverage     |   X   |    X   |         |    X    |    X    |
+| Mem             |   X   |    X   |    X    |    X    |    X    |
+| ProcArgs        |   X   |    X   |    X    |         |    X    |
+| ProcEnv         |   X   |    X   |         |         |    X    |
+| ProcExe         |   X   |    X   |         |         |    X    |
+| ProcFDUsage     |   X   |        |         |         |    X    |
+| ProcList        |   X   |    X   |    X    |         |    X    |
+| ProcMem         |   X   |    X   |    X    |         |    X    |
+| ProcState       |   X   |    X   |    X    |         |    X    |
+| ProcTime        |   X   |    X   |    X    |         |    X    |
+| Swap            |   X   |    X   |         |    X    |    X    |
+| Uptime          |   X   |    X   |         |    X    |    X    |
+
+## OS Specific Notes
+
+### FreeBSD
+
+Mount both `linprocfs` and `procfs` for compatability. Consider adding these
+mounts to your `/etc/fstab` file so they are mounted automatically at boot.
+
+```
+sudo mount -t procfs proc /proc
+sudo mkdir -p /compat/linux/proc
+sudo mount -t linprocfs /dev/null /compat/linux/proc
+```
+
+## License
+
+Apache 2.0

vendor/github.com/elastic/gosigar/Vagrantfile

@@ -0,0 +1,25 @@
+# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
+VAGRANTFILE_API_VERSION = "2"
+
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
+  config.vm.box = "hashicorp/precise64"
+  config.vm.provision "shell", inline: "mkdir -p /home/vagrant/go"
+  config.vm.synced_folder ".", "/home/vagrant/go/src/github.com/cloudfoundry/gosigar"
+  config.vm.provision "shell", inline: "chown -R vagrant:vagrant /home/vagrant/go"
+  install_go = <<-BASH
+  set -e
+
+if [ ! -d "/usr/local/go" ]; then
+	cd /tmp && wget https://storage.googleapis.com/golang/go1.3.3.linux-amd64.tar.gz
+	cd /usr/local
+	tar xvzf /tmp/go1.3.3.linux-amd64.tar.gz
+	echo 'export GOPATH=/home/vagrant/go; export PATH=/usr/local/go/bin:$PATH:$GOPATH/bin' >> /home/vagrant/.bashrc
+fi
+export GOPATH=/home/vagrant/go
+export PATH=/usr/local/go/bin:$PATH:$GOPATH/bin
+/usr/local/go/bin/go get -u github.com/onsi/ginkgo/ginkgo
+/usr/local/go/bin/go get -u github.com/onsi/gomega;
+BASH
+  config.vm.provision "shell", inline: 'apt-get install -y git-core'
+  config.vm.provision "shell", inline: install_go
+end

vendor/github.com/elastic/gosigar/codecov.yml

@@ -0,0 +1,21 @@
+# Enable coverage report message for diff on commit
+coverage:
+  status:
+    project: off
+    patch:
+      default:
+        # basic
+        target: auto
+        threshold: null
+        base: auto
+        # advanced
+        branches: null
+        if_no_uploads: error
+        if_not_found: success
+        if_ci_failed: error
+        only_pulls: false
+        flags: null
+        paths: null
+
+# Disable comments on Pull Requests
+comment: false

vendor/github.com/elastic/gosigar/concrete_sigar.go

@@ -0,0 +1,83 @@
+package gosigar
+
+import (
+	"time"
+)
+
+type ConcreteSigar struct{}
+
+func (c *ConcreteSigar) CollectCpuStats(collectionInterval time.Duration) (<-chan Cpu, chan<- struct{}) {
+	// samplesCh is buffered to 1 value to immediately return first CPU sample
+	samplesCh := make(chan Cpu, 1)
+
+	stopCh := make(chan struct{})
+
+	go func() {
+		var cpuUsage Cpu
+
+		// Immediately provide non-delta value.
+		// samplesCh is buffered to 1 value, so it will not block.
+		cpuUsage.Get()
+		samplesCh <- cpuUsage
+
+		ticker := time.NewTicker(collectionInterval)
+
+		for {
+			select {
+			case <-ticker.C:
+				previousCpuUsage := cpuUsage
+
+				cpuUsage.Get()
+
+				select {
+				case samplesCh <- cpuUsage.Delta(previousCpuUsage):
+				default:
+					// Include default to avoid channel blocking
+				}
+
+			case <-stopCh:
+				return
+			}
+		}
+	}()
+
+	return samplesCh, stopCh
+}
+
+func (c *ConcreteSigar) GetLoadAverage() (LoadAverage, error) {
+	l := LoadAverage{}
+	err := l.Get()
+	return l, err
+}
+
+func (c *ConcreteSigar) GetMem() (Mem, error) {
+	m := Mem{}
+	err := m.Get()
+	return m, err
+}
+
+func (c *ConcreteSigar) GetSwap() (Swap, error) {
+	s := Swap{}
+	err := s.Get()
+	return s, err
+}
+
+func (c *ConcreteSigar) GetFileSystemUsage(path string) (FileSystemUsage, error) {
+	f := FileSystemUsage{}
+	err := f.Get(path)
+	return f, err
+}
+
+func (c *ConcreteSigar) GetFDUsage() (FDUsage, error) {
+	fd := FDUsage{}
+	err := fd.Get()
+	return fd, err
+}
+
+// GetRusage return the resource usage of the process
+// Possible params: 0 = RUSAGE_SELF, 1 = RUSAGE_CHILDREN, 2 = RUSAGE_THREAD
+func (c *ConcreteSigar) GetRusage(who int) (Rusage, error) {
+	r := Rusage{}
+	err := r.Get(who)
+	return r, err
+}

vendor/github.com/elastic/gosigar/sigar_darwin.go

@@ -0,0 +1,494 @@
+// Copyright (c) 2012 VMware, Inc.
+
+package gosigar
+
+/*
+#include <stdlib.h>
+#include <sys/sysctl.h>
+#include <sys/mount.h>
+#include <mach/mach_init.h>
+#include <mach/mach_host.h>
+#include <mach/host_info.h>
+#include <libproc.h>
+#include <mach/processor_info.h>
+#include <mach/vm_map.h>
+*/
+import "C"
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"os/user"
+	"runtime"
+	"strconv"
+	"syscall"
+	"time"
+	"unsafe"
+)
+
+func (self *LoadAverage) Get() error {
+	avg := []C.double{0, 0, 0}
+
+	C.getloadavg(&avg[0], C.int(len(avg)))
+
+	self.One = float64(avg[0])
+	self.Five = float64(avg[1])
+	self.Fifteen = float64(avg[2])
+
+	return nil
+}
+
+func (self *Uptime) Get() error {
+	tv := syscall.Timeval32{}
+
+	if err := sysctlbyname("kern.boottime", &tv); err != nil {
+		return err
+	}
+
+	self.Length = time.Since(time.Unix(int64(tv.Sec), int64(tv.Usec)*1000)).Seconds()
+
+	return nil
+}
+
+func (self *Mem) Get() error {
+	var vmstat C.vm_statistics_data_t
+
+	if err := sysctlbyname("hw.memsize", &self.Total); err != nil {
+		return err
+	}
+
+	if err := vm_info(&vmstat); err != nil {
+		return err
+	}
+
+	kern := uint64(vmstat.inactive_count) << 12
+	self.Free = uint64(vmstat.free_count) << 12
+
+	self.Used = self.Total - self.Free
+	self.ActualFree = self.Free + kern
+	self.ActualUsed = self.Used - kern
+
+	return nil
+}
+
+type xsw_usage struct {
+	Total, Avail, Used uint64
+}
+
+func (self *Swap) Get() error {
+	sw_usage := xsw_usage{}
+
+	if err := sysctlbyname("vm.swapusage", &sw_usage); err != nil {
+		return err
+	}
+
+	self.Total = sw_usage.Total
+	self.Used = sw_usage.Used
+	self.Free = sw_usage.Avail
+
+	return nil
+}
+
+func (self *Cpu) Get() error {
+	var count C.mach_msg_type_number_t = C.HOST_CPU_LOAD_INFO_COUNT
+	var cpuload C.host_cpu_load_info_data_t
+
+	status := C.host_statistics(C.host_t(C.mach_host_self()),
+		C.HOST_CPU_LOAD_INFO,
+		C.host_info_t(unsafe.Pointer(&cpuload)),
+		&count)
+
+	if status != C.KERN_SUCCESS {
+		return fmt.Errorf("host_statistics error=%d", status)
+	}
+
+	self.User = uint64(cpuload.cpu_ticks[C.CPU_STATE_USER])
+	self.Sys = uint64(cpuload.cpu_ticks[C.CPU_STATE_SYSTEM])
+	self.Idle = uint64(cpuload.cpu_ticks[C.CPU_STATE_IDLE])
+	self.Nice = uint64(cpuload.cpu_ticks[C.CPU_STATE_NICE])
+
+	return nil
+}
+
+func (self *CpuList) Get() error {
+	var count C.mach_msg_type_number_t
+	var cpuload *C.processor_cpu_load_info_data_t
+	var ncpu C.natural_t
+
+	status := C.host_processor_info(C.host_t(C.mach_host_self()),
+		C.PROCESSOR_CPU_LOAD_INFO,
+		&ncpu,
+		(*C.processor_info_array_t)(unsafe.Pointer(&cpuload)),
+		&count)
+
+	if status != C.KERN_SUCCESS {
+		return fmt.Errorf("host_processor_info error=%d", status)
+	}
+
+	// jump through some cgo casting hoops and ensure we properly free
+	// the memory that cpuload points to
+	target := C.vm_map_t(C.mach_task_self_)
+	address := C.vm_address_t(uintptr(unsafe.Pointer(cpuload)))
+	defer C.vm_deallocate(target, address, C.vm_size_t(ncpu))
+
+	// the body of struct processor_cpu_load_info
+	// aka processor_cpu_load_info_data_t
+	var cpu_ticks [C.CPU_STATE_MAX]uint32
+
+	// copy the cpuload array to a []byte buffer
+	// where we can binary.Read the data
+	size := int(ncpu) * binary.Size(cpu_ticks)
+	buf := C.GoBytes(unsafe.Pointer(cpuload), C.int(size))
+
+	bbuf := bytes.NewBuffer(buf)
+
+	self.List = make([]Cpu, 0, ncpu)
+
+	for i := 0; i < int(ncpu); i++ {
+		cpu := Cpu{}
+
+		err := binary.Read(bbuf, binary.LittleEndian, &cpu_ticks)
+		if err != nil {
+			return err
+		}
+
+		cpu.User = uint64(cpu_ticks[C.CPU_STATE_USER])
+		cpu.Sys = uint64(cpu_ticks[C.CPU_STATE_SYSTEM])
+		cpu.Idle = uint64(cpu_ticks[C.CPU_STATE_IDLE])
+		cpu.Nice = uint64(cpu_ticks[C.CPU_STATE_NICE])
+
+		self.List = append(self.List, cpu)
+	}
+
+	return nil
+}
+
+func (self *FDUsage) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *FileSystemList) Get() error {
+	num, err := syscall.Getfsstat(nil, C.MNT_NOWAIT)
+	if err != nil {
+		return err
+	}
+
+	buf := make([]syscall.Statfs_t, num)
+
+	_, err = syscall.Getfsstat(buf, C.MNT_NOWAIT)
+	if err != nil {
+		return err
+	}
+
+	fslist := make([]FileSystem, 0, num)
+
+	for i := 0; i < num; i++ {
+		fs := FileSystem{}
+
+		fs.DirName = bytePtrToString(&buf[i].Mntonname[0])
+		fs.DevName = bytePtrToString(&buf[i].Mntfromname[0])
+		fs.SysTypeName = bytePtrToString(&buf[i].Fstypename[0])
+
+		fslist = append(fslist, fs)
+	}
+
+	self.List = fslist
+
+	return err
+}
+
+func (self *ProcList) Get() error {
+	n := C.proc_listpids(C.PROC_ALL_PIDS, 0, nil, 0)
+	if n <= 0 {
+		return syscall.EINVAL
+	}
+	buf := make([]byte, n)
+	n = C.proc_listpids(C.PROC_ALL_PIDS, 0, unsafe.Pointer(&buf[0]), n)
+	if n <= 0 {
+		return syscall.ENOMEM
+	}
+
+	var pid int32
+	num := int(n) / binary.Size(pid)
+	list := make([]int, 0, num)
+	bbuf := bytes.NewBuffer(buf)
+
+	for i := 0; i < num; i++ {
+		if err := binary.Read(bbuf, binary.LittleEndian, &pid); err != nil {
+			return err
+		}
+		if pid == 0 {
+			continue
+		}
+
+		list = append(list, int(pid))
+	}
+
+	self.List = list
+
+	return nil
+}
+
+func (self *ProcState) Get(pid int) error {
+	info := C.struct_proc_taskallinfo{}
+
+	if err := task_info(pid, &info); err != nil {
+		return err
+	}
+
+	self.Name = C.GoString(&info.pbsd.pbi_comm[0])
+
+	switch info.pbsd.pbi_status {
+	case C.SIDL:
+		self.State = RunStateIdle
+	case C.SRUN:
+		self.State = RunStateRun
+	case C.SSLEEP:
+		self.State = RunStateSleep
+	case C.SSTOP:
+		self.State = RunStateStop
+	case C.SZOMB:
+		self.State = RunStateZombie
+	default:
+		self.State = RunStateUnknown
+	}
+
+	self.Ppid = int(info.pbsd.pbi_ppid)
+
+	self.Pgid = int(info.pbsd.pbi_pgid)
+
+	self.Tty = int(info.pbsd.e_tdev)
+
+	self.Priority = int(info.ptinfo.pti_priority)
+
+	self.Nice = int(info.pbsd.pbi_nice)
+
+	// Get process username. Fallback to UID if username is not available.
+	uid := strconv.Itoa(int(info.pbsd.pbi_uid))
+	user, err := user.LookupId(uid)
+	if err == nil && user.Username != "" {
+		self.Username = user.Username
+	} else {
+		self.Username = uid
+	}
+
+	return nil
+}
+
+func (self *ProcMem) Get(pid int) error {
+	info := C.struct_proc_taskallinfo{}
+
+	if err := task_info(pid, &info); err != nil {
+		return err
+	}
+
+	self.Size = uint64(info.ptinfo.pti_virtual_size)
+	self.Resident = uint64(info.ptinfo.pti_resident_size)
+	self.PageFaults = uint64(info.ptinfo.pti_faults)
+
+	return nil
+}
+
+func (self *ProcTime) Get(pid int) error {
+	info := C.struct_proc_taskallinfo{}
+
+	if err := task_info(pid, &info); err != nil {
+		return err
+	}
+
+	self.User =
+		uint64(info.ptinfo.pti_total_user) / uint64(time.Millisecond)
+
+	self.Sys =
+		uint64(info.ptinfo.pti_total_system) / uint64(time.Millisecond)
+
+	self.Total = self.User + self.Sys
+
+	self.StartTime = (uint64(info.pbsd.pbi_start_tvsec) * 1000) +
+		(uint64(info.pbsd.pbi_start_tvusec) / 1000)
+
+	return nil
+}
+
+func (self *ProcArgs) Get(pid int) error {
+	var args []string
+
+	argv := func(arg string) {
+		args = append(args, arg)
+	}
+
+	err := kern_procargs(pid, nil, argv, nil)
+
+	self.List = args
+
+	return err
+}
+
+func (self *ProcEnv) Get(pid int) error {
+	if self.Vars == nil {
+		self.Vars = map[string]string{}
+	}
+
+	env := func(k, v string) {
+		self.Vars[k] = v
+	}
+
+	return kern_procargs(pid, nil, nil, env)
+}
+
+func (self *ProcExe) Get(pid int) error {
+	exe := func(arg string) {
+		self.Name = arg
+	}
+
+	return kern_procargs(pid, exe, nil, nil)
+}
+
+func (self *ProcFDUsage) Get(pid int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+// wrapper around sysctl KERN_PROCARGS2
+// callbacks params are optional,
+// up to the caller as to which pieces of data they want
+func kern_procargs(pid int,
+	exe func(string),
+	argv func(string),
+	env func(string, string)) error {
+
+	mib := []C.int{C.CTL_KERN, C.KERN_PROCARGS2, C.int(pid)}
+	argmax := uintptr(C.ARG_MAX)
+	buf := make([]byte, argmax)
+	err := sysctl(mib, &buf[0], &argmax, nil, 0)
+	if err != nil {
+		return nil
+	}
+
+	bbuf := bytes.NewBuffer(buf)
+	bbuf.Truncate(int(argmax))
+
+	var argc int32
+	binary.Read(bbuf, binary.LittleEndian, &argc)
+
+	path, err := bbuf.ReadBytes(0)
+	if err != nil {
+		return fmt.Errorf("Error reading the argv[0]: %v", err)
+	}
+	if exe != nil {
+		exe(string(chop(path)))
+	}
+
+	// skip trailing \0's
+	for {
+		c, err := bbuf.ReadByte()
+		if err != nil {
+			return fmt.Errorf("Error skipping nils: %v", err)
+		}
+		if c != 0 {
+			bbuf.UnreadByte()
+			break // start of argv[0]
+		}
+	}
+
+	for i := 0; i < int(argc); i++ {
+		arg, err := bbuf.ReadBytes(0)
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return fmt.Errorf("Error reading args: %v", err)
+		}
+		if argv != nil {
+			argv(string(chop(arg)))
+		}
+	}
+
+	if env == nil {
+		return nil
+	}
+
+	delim := []byte{61} // "="
+
+	for {
+		line, err := bbuf.ReadBytes(0)
+		if err == io.EOF || line[0] == 0 {
+			break
+		}
+		if err != nil {
+			return fmt.Errorf("Error reading args: %v", err)
+		}
+		pair := bytes.SplitN(chop(line), delim, 2)
+
+		if len(pair) != 2 {
+			return fmt.Errorf("Error reading process information for PID: %d", pid)
+		}
+
+		env(string(pair[0]), string(pair[1]))
+	}
+
+	return nil
+}
+
+// XXX copied from zsyscall_darwin_amd64.go
+func sysctl(mib []C.int, old *byte, oldlen *uintptr,
+	new *byte, newlen uintptr) (err error) {
+	var p0 unsafe.Pointer
+	p0 = unsafe.Pointer(&mib[0])
+	_, _, e1 := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(p0),
+		uintptr(len(mib)),
+		uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)),
+		uintptr(unsafe.Pointer(new)), uintptr(newlen))
+	if e1 != 0 {
+		err = e1
+	}
+	return
+}
+
+func vm_info(vmstat *C.vm_statistics_data_t) error {
+	var count C.mach_msg_type_number_t = C.HOST_VM_INFO_COUNT
+
+	status := C.host_statistics(
+		C.host_t(C.mach_host_self()),
+		C.HOST_VM_INFO,
+		C.host_info_t(unsafe.Pointer(vmstat)),
+		&count)
+
+	if status != C.KERN_SUCCESS {
+		return fmt.Errorf("host_statistics=%d", status)
+	}
+
+	return nil
+}
+
+// generic Sysctl buffer unmarshalling
+func sysctlbyname(name string, data interface{}) (err error) {
+	val, err := syscall.Sysctl(name)
+	if err != nil {
+		return err
+	}
+
+	buf := []byte(val)
+
+	switch v := data.(type) {
+	case *uint64:
+		*v = *(*uint64)(unsafe.Pointer(&buf[0]))
+		return
+	}
+
+	bbuf := bytes.NewBuffer([]byte(val))
+	return binary.Read(bbuf, binary.LittleEndian, data)
+}
+
+func task_info(pid int, info *C.struct_proc_taskallinfo) error {
+	size := C.int(unsafe.Sizeof(*info))
+	ptr := unsafe.Pointer(info)
+
+	n := C.proc_pidinfo(C.int(pid), C.PROC_PIDTASKALLINFO, 0, ptr, size)
+	if n != size {
+		return fmt.Errorf("Could not read process info for pid %d", pid)
+	}
+
+	return nil
+}

vendor/github.com/elastic/gosigar/sigar_format.go

@@ -0,0 +1,126 @@
+// Copyright (c) 2012 VMware, Inc.
+
+package gosigar
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"strconv"
+	"time"
+)
+
+// Go version of apr_strfsize
+func FormatSize(size uint64) string {
+	ord := []string{"K", "M", "G", "T", "P", "E"}
+	o := 0
+	buf := new(bytes.Buffer)
+	w := bufio.NewWriter(buf)
+
+	if size < 973 {
+		fmt.Fprintf(w, "%3d ", size)
+		w.Flush()
+		return buf.String()
+	}
+
+	for {
+		remain := size & 1023
+		size >>= 10
+
+		if size >= 973 {
+			o++
+			continue
+		}
+
+		if size < 9 || (size == 9 && remain < 973) {
+			remain = ((remain * 5) + 256) / 512
+			if remain >= 10 {
+				size++
+				remain = 0
+			}
+
+			fmt.Fprintf(w, "%d.%d%s", size, remain, ord[o])
+			break
+		}
+
+		if remain >= 512 {
+			size++
+		}
+
+		fmt.Fprintf(w, "%3d%s", size, ord[o])
+		break
+	}
+
+	w.Flush()
+	return buf.String()
+}
+
+func FormatPercent(percent float64) string {
+	return strconv.FormatFloat(percent, 'f', -1, 64) + "%"
+}
+
+func (self *FileSystemUsage) UsePercent() float64 {
+	b_used := (self.Total - self.Free) / 1024
+	b_avail := self.Avail / 1024
+	utotal := b_used + b_avail
+	used := b_used
+
+	if utotal != 0 {
+		u100 := used * 100
+		pct := u100 / utotal
+		if u100%utotal != 0 {
+			pct += 1
+		}
+		return (float64(pct) / float64(100)) * 100.0
+	}
+
+	return 0.0
+}
+
+func (self *Uptime) Format() string {
+	buf := new(bytes.Buffer)
+	w := bufio.NewWriter(buf)
+	uptime := uint64(self.Length)
+
+	days := uptime / (60 * 60 * 24)
+
+	if days != 0 {
+		s := ""
+		if days > 1 {
+			s = "s"
+		}
+		fmt.Fprintf(w, "%d day%s, ", days, s)
+	}
+
+	minutes := uptime / 60
+	hours := minutes / 60
+	hours %= 24
+	minutes %= 60
+
+	fmt.Fprintf(w, "%2d:%02d", hours, minutes)
+
+	w.Flush()
+	return buf.String()
+}
+
+func (self *ProcTime) FormatStartTime() string {
+	if self.StartTime == 0 {
+		return "00:00"
+	}
+	start := time.Unix(int64(self.StartTime)/1000, 0)
+	format := "Jan02"
+	if time.Since(start).Seconds() < (60 * 60 * 24) {
+		format = "15:04"
+	}
+	return start.Format(format)
+}
+
+func (self *ProcTime) FormatTotal() string {
+	t := self.Total / 1000
+	ss := t % 60
+	t /= 60
+	mm := t % 60
+	t /= 60
+	hh := t % 24
+	return fmt.Sprintf("%02d:%02d:%02d", hh, mm, ss)
+}

vendor/github.com/elastic/gosigar/sigar_freebsd.go

@@ -0,0 +1,108 @@
+// Copied and modified from sigar_linux.go.
+
+package gosigar
+
+import (
+	"io/ioutil"
+	"strconv"
+	"strings"
+	"unsafe"
+)
+
+/*
+#include <sys/param.h>
+#include <sys/mount.h>
+#include <sys/ucred.h>
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <time.h>
+*/
+import "C"
+
+func init() {
+	system.ticks = uint64(C.sysconf(C._SC_CLK_TCK))
+
+	Procd = "/compat/linux/proc"
+
+	getLinuxBootTime()
+}
+
+func getMountTableFileName() string {
+	return Procd + "/mtab"
+}
+
+func (self *Uptime) Get() error {
+	ts := C.struct_timespec{}
+
+	if _, err := C.clock_gettime(C.CLOCK_UPTIME, &ts); err != nil {
+		return err
+	}
+
+	self.Length = float64(ts.tv_sec) + 1e-9*float64(ts.tv_nsec)
+
+	return nil
+}
+
+func (self *FDUsage) Get() error {
+	val := C.uint32_t(0)
+	sc := C.size_t(4)
+
+	name := C.CString("kern.openfiles")
+	_, err := C.sysctlbyname(name, unsafe.Pointer(&val), &sc, nil, 0)
+	C.free(unsafe.Pointer(name))
+	if err != nil {
+		return err
+	}
+	self.Open = uint64(val)
+
+	name = C.CString("kern.maxfiles")
+	_, err = C.sysctlbyname(name, unsafe.Pointer(&val), &sc, nil, 0)
+	C.free(unsafe.Pointer(name))
+	if err != nil {
+		return err
+	}
+	self.Max = uint64(val)
+
+	self.Unused = self.Max - self.Open
+
+	return nil
+}
+
+func (self *ProcFDUsage) Get(pid int) error {
+	err := readFile("/proc/"+strconv.Itoa(pid)+"/rlimit", func(line string) bool {
+		if strings.HasPrefix(line, "nofile") {
+			fields := strings.Fields(line)
+			if len(fields) == 3 {
+				self.SoftLimit, _ = strconv.ParseUint(fields[1], 10, 64)
+				self.HardLimit, _ = strconv.ParseUint(fields[2], 10, 64)
+			}
+			return false
+		}
+		return true
+	})
+	if err != nil {
+		return err
+	}
+
+	// linprocfs only provides this information for this process (self).
+	fds, err := ioutil.ReadDir(procFileName(pid, "fd"))
+	if err != nil {
+		return err
+	}
+	self.Open = uint64(len(fds))
+
+	return nil
+}
+
+func parseCpuStat(self *Cpu, line string) error {
+	fields := strings.Fields(line)
+
+	self.User, _ = strtoull(fields[1])
+	self.Nice, _ = strtoull(fields[2])
+	self.Sys, _ = strtoull(fields[3])
+	self.Idle, _ = strtoull(fields[4])
+	return nil
+}

vendor/github.com/elastic/gosigar/sigar_interface.go

@@ -0,0 +1,197 @@
+package gosigar
+
+import (
+	"time"
+)
+
+type ErrNotImplemented struct {
+	OS string
+}
+
+func (e ErrNotImplemented) Error() string {
+	return "not implemented on " + e.OS
+}
+
+func IsNotImplemented(err error) bool {
+	switch err.(type) {
+	case ErrNotImplemented, *ErrNotImplemented:
+		return true
+	default:
+		return false
+	}
+}
+
+type Sigar interface {
+	CollectCpuStats(collectionInterval time.Duration) (<-chan Cpu, chan<- struct{})
+	GetLoadAverage() (LoadAverage, error)
+	GetMem() (Mem, error)
+	GetSwap() (Swap, error)
+	GetFileSystemUsage(string) (FileSystemUsage, error)
+	GetFDUsage() (FDUsage, error)
+	GetRusage(who int) (Rusage, error)
+}
+
+type Cpu struct {
+	User    uint64
+	Nice    uint64
+	Sys     uint64
+	Idle    uint64
+	Wait    uint64
+	Irq     uint64
+	SoftIrq uint64
+	Stolen  uint64
+}
+
+func (cpu *Cpu) Total() uint64 {
+	return cpu.User + cpu.Nice + cpu.Sys + cpu.Idle +
+		cpu.Wait + cpu.Irq + cpu.SoftIrq + cpu.Stolen
+}
+
+func (cpu Cpu) Delta(other Cpu) Cpu {
+	return Cpu{
+		User:    cpu.User - other.User,
+		Nice:    cpu.Nice - other.Nice,
+		Sys:     cpu.Sys - other.Sys,
+		Idle:    cpu.Idle - other.Idle,
+		Wait:    cpu.Wait - other.Wait,
+		Irq:     cpu.Irq - other.Irq,
+		SoftIrq: cpu.SoftIrq - other.SoftIrq,
+		Stolen:  cpu.Stolen - other.Stolen,
+	}
+}
+
+type LoadAverage struct {
+	One, Five, Fifteen float64
+}
+
+type Uptime struct {
+	Length float64
+}
+
+type Mem struct {
+	Total      uint64
+	Used       uint64
+	Free       uint64
+	ActualFree uint64
+	ActualUsed uint64
+}
+
+type Swap struct {
+	Total uint64
+	Used  uint64
+	Free  uint64
+}
+
+type CpuList struct {
+	List []Cpu
+}
+
+type FDUsage struct {
+	Open   uint64
+	Unused uint64
+	Max    uint64
+}
+
+type FileSystem struct {
+	DirName     string
+	DevName     string
+	TypeName    string
+	SysTypeName string
+	Options     string
+	Flags       uint32
+}
+
+type FileSystemList struct {
+	List []FileSystem
+}
+
+type FileSystemUsage struct {
+	Total     uint64
+	Used      uint64
+	Free      uint64
+	Avail     uint64
+	Files     uint64
+	FreeFiles uint64
+}
+
+type ProcList struct {
+	List []int
+}
+
+type RunState byte
+
+const (
+	RunStateSleep   = 'S'
+	RunStateRun     = 'R'
+	RunStateStop    = 'T'
+	RunStateZombie  = 'Z'
+	RunStateIdle    = 'D'
+	RunStateUnknown = '?'
+)
+
+type ProcState struct {
+	Name      string
+	Username  string
+	State     RunState
+	Ppid      int
+	Pgid      int
+	Tty       int
+	Priority  int
+	Nice      int
+	Processor int
+}
+
+type ProcMem struct {
+	Size        uint64
+	Resident    uint64
+	Share       uint64
+	MinorFaults uint64
+	MajorFaults uint64
+	PageFaults  uint64
+}
+
+type ProcTime struct {
+	StartTime uint64
+	User      uint64
+	Sys       uint64
+	Total     uint64
+}
+
+type ProcArgs struct {
+	List []string
+}
+
+type ProcEnv struct {
+	Vars map[string]string
+}
+
+type ProcExe struct {
+	Name string
+	Cwd  string
+	Root string
+}
+
+type ProcFDUsage struct {
+	Open      uint64
+	SoftLimit uint64
+	HardLimit uint64
+}
+
+type Rusage struct {
+	Utime    time.Duration
+	Stime    time.Duration
+	Maxrss   int64
+	Ixrss    int64
+	Idrss    int64
+	Isrss    int64
+	Minflt   int64
+	Majflt   int64
+	Nswap    int64
+	Inblock  int64
+	Oublock  int64
+	Msgsnd   int64
+	Msgrcv   int64
+	Nsignals int64
+	Nvcsw    int64
+	Nivcsw   int64
+}

vendor/github.com/elastic/gosigar/sigar_linux.go

@@ -0,0 +1,84 @@
+// Copyright (c) 2012 VMware, Inc.
+
+package gosigar
+
+import (
+	"io/ioutil"
+	"strconv"
+	"strings"
+	"syscall"
+)
+
+func init() {
+	system.ticks = 100 // C.sysconf(C._SC_CLK_TCK)
+
+	Procd = "/proc"
+
+	getLinuxBootTime()
+}
+
+func getMountTableFileName() string {
+	return "/etc/mtab"
+}
+
+func (self *Uptime) Get() error {
+	sysinfo := syscall.Sysinfo_t{}
+
+	if err := syscall.Sysinfo(&sysinfo); err != nil {
+		return err
+	}
+
+	self.Length = float64(sysinfo.Uptime)
+
+	return nil
+}
+
+func (self *FDUsage) Get() error {
+	return readFile(Procd+"/sys/fs/file-nr", func(line string) bool {
+		fields := strings.Fields(line)
+		if len(fields) == 3 {
+			self.Open, _ = strconv.ParseUint(fields[0], 10, 64)
+			self.Unused, _ = strconv.ParseUint(fields[1], 10, 64)
+			self.Max, _ = strconv.ParseUint(fields[2], 10, 64)
+		}
+		return false
+	})
+}
+
+func (self *ProcFDUsage) Get(pid int) error {
+	err := readFile(procFileName(pid, "limits"), func(line string) bool {
+		if strings.HasPrefix(line, "Max open files") {
+			fields := strings.Fields(line)
+			if len(fields) == 6 {
+				self.SoftLimit, _ = strconv.ParseUint(fields[3], 10, 64)
+				self.HardLimit, _ = strconv.ParseUint(fields[4], 10, 64)
+			}
+			return false
+		}
+		return true
+	})
+	if err != nil {
+		return err
+	}
+	fds, err := ioutil.ReadDir(procFileName(pid, "fd"))
+	if err != nil {
+		return err
+	}
+	self.Open = uint64(len(fds))
+	return nil
+}
+
+func parseCpuStat(self *Cpu, line string) error {
+	fields := strings.Fields(line)
+
+	self.User, _ = strtoull(fields[1])
+	self.Nice, _ = strtoull(fields[2])
+	self.Sys, _ = strtoull(fields[3])
+	self.Idle, _ = strtoull(fields[4])
+	self.Wait, _ = strtoull(fields[5])
+	self.Irq, _ = strtoull(fields[6])
+	self.SoftIrq, _ = strtoull(fields[7])
+	self.Stolen, _ = strtoull(fields[8])
+
+	return nil
+}

vendor/github.com/elastic/gosigar/sigar_linux_common.go

@@ -0,0 +1,468 @@
+// Copyright (c) 2012 VMware, Inc.
+
+// +build freebsd linux
+
+package gosigar
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"os/user"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"syscall"
+)
+
+var system struct {
+	ticks uint64
+	btime uint64
+}
+
+var Procd string
+
+func getLinuxBootTime() {
+	// grab system boot time
+	readFile(Procd+"/stat", func(line string) bool {
+		if strings.HasPrefix(line, "btime") {
+			system.btime, _ = strtoull(line[6:])
+			return false // stop reading
+		}
+		return true
+	})
+}
+
+func (self *LoadAverage) Get() error {
+	line, err := ioutil.ReadFile(Procd + "/loadavg")
+	if err != nil {
+		return nil
+	}
+
+	fields := strings.Fields(string(line))
+
+	self.One, _ = strconv.ParseFloat(fields[0], 64)
+	self.Five, _ = strconv.ParseFloat(fields[1], 64)
+	self.Fifteen, _ = strconv.ParseFloat(fields[2], 64)
+
+	return nil
+}
+
+func (self *Mem) Get() error {
+
+	table, err := parseMeminfo()
+	if err != nil {
+		return err
+	}
+
+	self.Total, _ = table["MemTotal"]
+	self.Free, _ = table["MemFree"]
+	buffers, _ := table["Buffers"]
+	cached, _ := table["Cached"]
+
+	if available, ok := table["MemAvailable"]; ok {
+		// MemAvailable is in /proc/meminfo (kernel 3.14+)
+		self.ActualFree = available
+	} else {
+		self.ActualFree = self.Free + buffers + cached
+	}
+
+	self.Used = self.Total - self.Free
+	self.ActualUsed = self.Total - self.ActualFree
+
+	return nil
+}
+
+func (self *Swap) Get() error {
+
+	table, err := parseMeminfo()
+	if err != nil {
+		return err
+	}
+	self.Total, _ = table["SwapTotal"]
+	self.Free, _ = table["SwapFree"]
+
+	self.Used = self.Total - self.Free
+	return nil
+}
+
+func (self *Cpu) Get() error {
+	return readFile(Procd+"/stat", func(line string) bool {
+		if len(line) > 4 && line[0:4] == "cpu " {
+			parseCpuStat(self, line)
+			return false
+		}
+		return true
+
+	})
+}
+
+func (self *CpuList) Get() error {
+	capacity := len(self.List)
+	if capacity == 0 {
+		capacity = 4
+	}
+	list := make([]Cpu, 0, capacity)
+
+	err := readFile(Procd+"/stat", func(line string) bool {
+		if len(line) > 3 && line[0:3] == "cpu" && line[3] != ' ' {
+			cpu := Cpu{}
+			parseCpuStat(&cpu, line)
+			list = append(list, cpu)
+		}
+		return true
+	})
+
+	self.List = list
+
+	return err
+}
+
+func (self *FileSystemList) Get() error {
+	capacity := len(self.List)
+	if capacity == 0 {
+		capacity = 10
+	}
+	fslist := make([]FileSystem, 0, capacity)
+
+	err := readFile(getMountTableFileName(), func(line string) bool {
+		fields := strings.Fields(line)
+
+		fs := FileSystem{}
+		fs.DevName = fields[0]
+		fs.DirName = fields[1]
+		fs.SysTypeName = fields[2]
+		fs.Options = fields[3]
+
+		fslist = append(fslist, fs)
+
+		return true
+	})
+
+	self.List = fslist
+
+	return err
+}
+
+func (self *ProcList) Get() error {
+	dir, err := os.Open(Procd)
+	if err != nil {
+		return err
+	}
+	defer dir.Close()
+
+	const readAllDirnames = -1 // see os.File.Readdirnames doc
+
+	names, err := dir.Readdirnames(readAllDirnames)
+	if err != nil {
+		return err
+	}
+
+	capacity := len(names)
+	list := make([]int, 0, capacity)
+
+	for _, name := range names {
+		if name[0] < '0' || name[0] > '9' {
+			continue
+		}
+		pid, err := strconv.Atoi(name)
+		if err == nil {
+			list = append(list, pid)
+		}
+	}
+
+	self.List = list
+
+	return nil
+}
+
+func (self *ProcState) Get(pid int) error {
+	data, err := readProcFile(pid, "stat")
+	if err != nil {
+		return err
+	}
+
+	// Extract the comm value with is surrounded by parentheses.
+	lIdx := bytes.Index(data, []byte("("))
+	rIdx := bytes.LastIndex(data, []byte(")"))
+	if lIdx < 0 || rIdx < 0 || lIdx >= rIdx || rIdx+2 >= len(data) {
+		return fmt.Errorf("failed to extract comm for pid %d from '%v'", pid, string(data))
+	}
+	self.Name = string(data[lIdx+1 : rIdx])
+
+	// Extract the rest of the fields that we are interested in.
+	fields := bytes.Fields(data[rIdx+2:])
+	if len(fields) <= 36 {
+		return fmt.Errorf("expected more stat fields for pid %d from '%v'", pid, string(data))
+	}
+
+	interests := bytes.Join([][]byte{
+		fields[0],  // state
+		fields[1],  // ppid
+		fields[2],  // pgrp
+		fields[4],  // tty_nr
+		fields[15], // priority
+		fields[16], // nice
+		fields[36], // processor (last processor executed on)
+	}, []byte(" "))
+
+	var state string
+	_, err = fmt.Fscan(bytes.NewBuffer(interests),
+		&state,
+		&self.Ppid,
+		&self.Pgid,
+		&self.Tty,
+		&self.Priority,
+		&self.Nice,
+		&self.Processor,
+	)
+	if err != nil {
+		return fmt.Errorf("failed to parse stat fields for pid %d from '%v': %v", pid, string(data), err)
+	}
+	self.State = RunState(state[0])
+
+	// Read /proc/[pid]/status to get the uid, then lookup uid to get username.
+	status, err := getProcStatus(pid)
+	if err != nil {
+		return fmt.Errorf("failed to read process status for pid %d: %v", pid, err)
+	}
+	uids, err := getUIDs(status)
+	if err != nil {
+		return fmt.Errorf("failed to read process status for pid %d: %v", pid, err)
+	}
+	user, err := user.LookupId(uids[0])
+	if err == nil {
+		self.Username = user.Username
+	} else {
+		self.Username = uids[0]
+	}
+
+	return nil
+}
+
+func (self *ProcMem) Get(pid int) error {
+	contents, err := readProcFile(pid, "statm")
+	if err != nil {
+		return err
+	}
+
+	fields := strings.Fields(string(contents))
+
+	size, _ := strtoull(fields[0])
+	self.Size = size << 12
+
+	rss, _ := strtoull(fields[1])
+	self.Resident = rss << 12
+
+	share, _ := strtoull(fields[2])
+	self.Share = share << 12
+
+	contents, err = readProcFile(pid, "stat")
+	if err != nil {
+		return err
+	}
+
+	fields = strings.Fields(string(contents))
+
+	self.MinorFaults, _ = strtoull(fields[10])
+	self.MajorFaults, _ = strtoull(fields[12])
+	self.PageFaults = self.MinorFaults + self.MajorFaults
+
+	return nil
+}
+
+func (self *ProcTime) Get(pid int) error {
+	contents, err := readProcFile(pid, "stat")
+	if err != nil {
+		return err
+	}
+
+	fields := strings.Fields(string(contents))
+
+	user, _ := strtoull(fields[13])
+	sys, _ := strtoull(fields[14])
+	// convert to millis
+	self.User = user * (1000 / system.ticks)
+	self.Sys = sys * (1000 / system.ticks)
+	self.Total = self.User + self.Sys
+
+	// convert to millis
+	self.StartTime, _ = strtoull(fields[21])
+	self.StartTime /= system.ticks
+	self.StartTime += system.btime
+	self.StartTime *= 1000
+
+	return nil
+}
+
+func (self *ProcArgs) Get(pid int) error {
+	contents, err := readProcFile(pid, "cmdline")
+	if err != nil {
+		return err
+	}
+
+	bbuf := bytes.NewBuffer(contents)
+
+	var args []string
+
+	for {
+		arg, err := bbuf.ReadBytes(0)
+		if err == io.EOF {
+			break
+		}
+		args = append(args, string(chop(arg)))
+	}
+
+	self.List = args
+
+	return nil
+}
+
+func (self *ProcEnv) Get(pid int) error {
+	contents, err := readProcFile(pid, "environ")
+	if err != nil {
+		return err
+	}
+
+	if self.Vars == nil {
+		self.Vars = map[string]string{}
+	}
+
+	pairs := bytes.Split(contents, []byte{0})
+	for _, kv := range pairs {
+		parts := bytes.SplitN(kv, []byte{'='}, 2)
+		if len(parts) != 2 {
+			continue
+		}
+
+		key := string(bytes.TrimSpace(parts[0]))
+		if key == "" {
+			continue
+		}
+
+		self.Vars[key] = string(bytes.TrimSpace(parts[1]))
+	}
+
+	return nil
+}
+
+func (self *ProcExe) Get(pid int) error {
+	fields := map[string]*string{
+		"exe":  &self.Name,
+		"cwd":  &self.Cwd,
+		"root": &self.Root,
+	}
+
+	for name, field := range fields {
+		val, err := os.Readlink(procFileName(pid, name))
+
+		if err != nil {
+			return err
+		}
+
+		*field = val
+	}
+
+	return nil
+}
+
+func parseMeminfo() (map[string]uint64, error) {
+	table := map[string]uint64{}
+
+	err := readFile(Procd+"/meminfo", func(line string) bool {
+		fields := strings.Split(line, ":")
+
+		if len(fields) != 2 {
+			return true // skip on errors
+		}
+
+		num := strings.TrimLeft(fields[1], " ")
+		val, err := strtoull(strings.Fields(num)[0])
+		if err != nil {
+			return true // skip on errors
+		}
+		table[fields[0]] = val * 1024 //in bytes
+
+		return true
+	})
+	return table, err
+}
+
+func readFile(file string, handler func(string) bool) error {
+	contents, err := ioutil.ReadFile(file)
+	if err != nil {
+		return err
+	}
+
+	reader := bufio.NewReader(bytes.NewBuffer(contents))
+
+	for {
+		line, _, err := reader.ReadLine()
+		if err == io.EOF {
+			break
+		}
+		if !handler(string(line)) {
+			break
+		}
+	}
+
+	return nil
+}
+
+func strtoull(val string) (uint64, error) {
+	return strconv.ParseUint(val, 10, 64)
+}
+
+func procFileName(pid int, name string) string {
+	return Procd + "/" + strconv.Itoa(pid) + "/" + name
+}
+
+func readProcFile(pid int, name string) ([]byte, error) {
+	path := procFileName(pid, name)
+	contents, err := ioutil.ReadFile(path)
+
+	if err != nil {
+		if perr, ok := err.(*os.PathError); ok {
+			if perr.Err == syscall.ENOENT {
+				return nil, syscall.ESRCH
+			}
+		}
+	}
+
+	return contents, err
+}
+
+// getProcStatus reads /proc/[pid]/status which contains process status
+// information in human readable form.
+func getProcStatus(pid int) (map[string]string, error) {
+	status := make(map[string]string, 42)
+	path := filepath.Join(Procd, strconv.Itoa(pid), "status")
+	err := readFile(path, func(line string) bool {
+		fields := strings.SplitN(line, ":", 2)
+		if len(fields) == 2 {
+			status[fields[0]] = strings.TrimSpace(fields[1])
+		}
+
+		return true
+	})
+	return status, err
+}
+
+// getUIDs reads the "Uid" value from status and splits it into four values --
+// real, effective, saved set, and  file system UIDs.
+func getUIDs(status map[string]string) ([]string, error) {
+	uidLine, ok := status["Uid"]
+	if !ok {
+		return nil, fmt.Errorf("Uid not found in proc status")
+	}
+
+	uidStrs := strings.Fields(uidLine)
+	if len(uidStrs) != 4 {
+		return nil, fmt.Errorf("Uid line ('%s') did not contain four values", uidLine)
+	}
+
+	return uidStrs, nil
+}

vendor/github.com/elastic/gosigar/sigar_openbsd.go

@@ -0,0 +1,418 @@
+// Copyright (c) 2016 Jasper Lievisse Adriaanse <j@jasper.la>.
+
+// +build openbsd
+
+package gosigar
+
+/*
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#include <sys/mount.h>
+#include <sys/sched.h>
+#include <sys/swap.h>
+#include <stdlib.h>
+#include <unistd.h>
+*/
+import "C"
+
+//import "github.com/davecgh/go-spew/spew"
+
+import (
+	"runtime"
+	"syscall"
+	"time"
+	"unsafe"
+)
+
+type Uvmexp struct {
+	pagesize           uint32
+	pagemask           uint32
+	pageshift          uint32
+	npages             uint32
+	free               uint32
+	active             uint32
+	inactive           uint32
+	paging             uint32
+	wired              uint32
+	zeropages          uint32
+	reserve_pagedaemon uint32
+	reserve_kernel     uint32
+	anonpages          uint32
+	vnodepages         uint32
+	vtextpages         uint32
+	freemin            uint32
+	freetarg           uint32
+	inactarg           uint32
+	wiredmax           uint32
+	anonmin            uint32
+	vtextmin           uint32
+	vnodemin           uint32
+	anonminpct         uint32
+	vtextmi            uint32
+	npct               uint32
+	vnodeminpct        uint32
+	nswapdev           uint32
+	swpages            uint32
+	swpginuse          uint32
+	swpgonly           uint32
+	nswget             uint32
+	nanon              uint32
+	nanonneeded        uint32
+	nfreeanon          uint32
+	faults             uint32
+	traps              uint32
+	intrs              uint32
+	swtch              uint32
+	softs              uint32
+	syscalls           uint32
+	pageins            uint32
+	obsolete_swapins   uint32
+	obsolete_swapouts  uint32
+	pgswapin           uint32
+	pgswapout          uint32
+	forks              uint32
+	forks_ppwait       uint32
+	forks_sharevm      uint32
+	pga_zerohit        uint32
+	pga_zeromiss       uint32
+	zeroaborts         uint32
+	fltnoram           uint32
+	fltnoanon          uint32
+	fltpgwait          uint32
+	fltpgrele          uint32
+	fltrelck           uint32
+	fltrelckok         uint32
+	fltanget           uint32
+	fltanretry         uint32
+	fltamcopy          uint32
+	fltnamap           uint32
+	fltnomap           uint32
+	fltlget            uint32
+	fltget             uint32
+	flt_anon           uint32
+	flt_acow           uint32
+	flt_obj            uint32
+	flt_prcopy         uint32
+	flt_przero         uint32
+	pdwoke             uint32
+	pdrevs             uint32
+	pdswout            uint32
+	pdfreed            uint32
+	pdscans            uint32
+	pdanscan           uint32
+	pdobscan           uint32
+	pdreact            uint32
+	pdbusy             uint32
+	pdpageouts         uint32
+	pdpending          uint32
+	pddeact            uint32
+	pdreanon           uint32
+	pdrevnode          uint32
+	pdrevtext          uint32
+	fpswtch            uint32
+	kmapent            uint32
+}
+
+type Bcachestats struct {
+	numbufs        uint64
+	numbufpages    uint64
+	numdirtypages  uint64
+	numcleanpages  uint64
+	pendingwrites  uint64
+	pendingreads   uint64
+	numwrites      uint64
+	numreads       uint64
+	cachehits      uint64
+	busymapped     uint64
+	dmapages       uint64
+	highpages      uint64
+	delwribufs     uint64
+	kvaslots       uint64
+	kvaslots_avail uint64
+}
+
+type Swapent struct {
+	se_dev      C.dev_t
+	se_flags    int32
+	se_nblks    int32
+	se_inuse    int32
+	se_priority int32
+	sw_path     []byte
+}
+
+func (self *FileSystemList) Get() error {
+	num, err := syscall.Getfsstat(nil, C.MNT_NOWAIT)
+	if err != nil {
+		return err
+	}
+
+	buf := make([]syscall.Statfs_t, num)
+
+	_, err = syscall.Getfsstat(buf, C.MNT_NOWAIT)
+	if err != nil {
+		return err
+	}
+
+	fslist := make([]FileSystem, 0, num)
+
+	for i := 0; i < num; i++ {
+		fs := FileSystem{}
+
+		fs.DirName = bytePtrToString(&buf[i].F_mntonname[0])
+		fs.DevName = bytePtrToString(&buf[i].F_mntfromname[0])
+		fs.SysTypeName = bytePtrToString(&buf[i].F_fstypename[0])
+
+		fslist = append(fslist, fs)
+	}
+
+	self.List = fslist
+
+	return err
+}
+
+func (self *FileSystemUsage) Get(path string) error {
+	stat := syscall.Statfs_t{}
+	err := syscall.Statfs(path, &stat)
+	if err != nil {
+		return err
+	}
+
+	self.Total = uint64(stat.F_blocks) * uint64(stat.F_bsize)
+	self.Free = uint64(stat.F_bfree) * uint64(stat.F_bsize)
+	self.Avail = uint64(stat.F_bavail) * uint64(stat.F_bsize)
+	self.Used = self.Total - self.Free
+	self.Files = stat.F_files
+	self.FreeFiles = stat.F_ffree
+
+	return nil
+}
+
+func (self *FDUsage) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *LoadAverage) Get() error {
+	avg := []C.double{0, 0, 0}
+
+	C.getloadavg(&avg[0], C.int(len(avg)))
+
+	self.One = float64(avg[0])
+	self.Five = float64(avg[1])
+	self.Fifteen = float64(avg[2])
+
+	return nil
+}
+
+func (self *Uptime) Get() error {
+	tv := syscall.Timeval{}
+	mib := [2]int32{C.CTL_KERN, C.KERN_BOOTTIME}
+
+	n := uintptr(0)
+	// First we determine how much memory we'll need to pass later on (via `n`)
+	_, _, errno := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 2, 0, uintptr(unsafe.Pointer(&n)), 0, 0)
+
+	if errno != 0 || n == 0 {
+		return nil
+	}
+
+	// Now perform the actual sysctl(3) call, storing the result in tv
+	_, _, errno = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 2, uintptr(unsafe.Pointer(&tv)), uintptr(unsafe.Pointer(&n)), 0, 0)
+
+	if errno != 0 || n == 0 {
+		return nil
+	}
+
+	self.Length = time.Since(time.Unix(int64(tv.Sec), int64(tv.Usec)*1000)).Seconds()
+
+	return nil
+}
+
+func (self *Mem) Get() error {
+	n := uintptr(0)
+
+	var uvmexp Uvmexp
+	mib := [2]int32{C.CTL_VM, C.VM_UVMEXP}
+	n = uintptr(0)
+	// First we determine how much memory we'll need to pass later on (via `n`)
+	_, _, errno := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 2, 0, uintptr(unsafe.Pointer(&n)), 0, 0)
+	if errno != 0 || n == 0 {
+		return nil
+	}
+
+	_, _, errno = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 2, uintptr(unsafe.Pointer(&uvmexp)), uintptr(unsafe.Pointer(&n)), 0, 0)
+	if errno != 0 || n == 0 {
+		return nil
+	}
+
+	var bcachestats Bcachestats
+	mib3 := [3]int32{C.CTL_VFS, C.VFS_GENERIC, C.VFS_BCACHESTAT}
+	n = uintptr(0)
+	_, _, errno = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib3[0])), 3, 0, uintptr(unsafe.Pointer(&n)), 0, 0)
+	if errno != 0 || n == 0 {
+		return nil
+	}
+	_, _, errno = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib3[0])), 3, uintptr(unsafe.Pointer(&bcachestats)), uintptr(unsafe.Pointer(&n)), 0, 0)
+	if errno != 0 || n == 0 {
+		return nil
+	}
+
+	self.Total = uint64(uvmexp.npages) << uvmexp.pageshift
+	self.Used = uint64(uvmexp.npages-uvmexp.free) << uvmexp.pageshift
+	self.Free = uint64(uvmexp.free) << uvmexp.pageshift
+
+	self.ActualFree = self.Free + (uint64(bcachestats.numbufpages) << uvmexp.pageshift)
+	self.ActualUsed = self.Used - (uint64(bcachestats.numbufpages) << uvmexp.pageshift)
+
+	return nil
+}
+
+func (self *Swap) Get() error {
+	nswap := C.swapctl(C.SWAP_NSWAP, unsafe.Pointer(uintptr(0)), 0)
+
+	// If there are no swap devices, nothing to do here.
+	if nswap == 0 {
+		return nil
+	}
+
+	swdev := make([]Swapent, nswap)
+
+	rnswap := C.swapctl(C.SWAP_STATS, unsafe.Pointer(&swdev[0]), nswap)
+	if rnswap == 0 {
+		return nil
+	}
+
+	for i := 0; i < int(nswap); i++ {
+		if swdev[i].se_flags&C.SWF_ENABLE == 2 {
+			self.Used = self.Used + uint64(swdev[i].se_inuse/(1024/C.DEV_BSIZE))
+			self.Total = self.Total + uint64(swdev[i].se_nblks/(1024/C.DEV_BSIZE))
+		}
+	}
+
+	self.Free = self.Total - self.Used
+
+	return nil
+}
+
+func (self *Cpu) Get() error {
+	load := [C.CPUSTATES]C.long{C.CP_USER, C.CP_NICE, C.CP_SYS, C.CP_INTR, C.CP_IDLE}
+
+	mib := [2]int32{C.CTL_KERN, C.KERN_CPTIME}
+	n := uintptr(0)
+	// First we determine how much memory we'll need to pass later on (via `n`)
+	_, _, errno := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 2, 0, uintptr(unsafe.Pointer(&n)), 0, 0)
+	if errno != 0 || n == 0 {
+		return nil
+	}
+
+	_, _, errno = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 2, uintptr(unsafe.Pointer(&load)), uintptr(unsafe.Pointer(&n)), 0, 0)
+	if errno != 0 || n == 0 {
+		return nil
+	}
+
+	self.User = uint64(load[0])
+	self.Nice = uint64(load[1])
+	self.Sys = uint64(load[2])
+	self.Irq = uint64(load[3])
+	self.Idle = uint64(load[4])
+
+	return nil
+}
+
+func (self *CpuList) Get() error {
+	mib := [2]int32{C.CTL_HW, C.HW_NCPU}
+	var ncpu int
+
+	n := uintptr(0)
+	// First we determine how much memory we'll need to pass later on (via `n`)
+	_, _, errno := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 2, 0, uintptr(unsafe.Pointer(&n)), 0, 0)
+
+	if errno != 0 || n == 0 {
+		return nil
+	}
+
+	// Now perform the actual sysctl(3) call, storing the result in ncpu
+	_, _, errno = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 2, uintptr(unsafe.Pointer(&ncpu)), uintptr(unsafe.Pointer(&n)), 0, 0)
+
+	if errno != 0 || n == 0 {
+		return nil
+	}
+
+	load := [C.CPUSTATES]C.long{C.CP_USER, C.CP_NICE, C.CP_SYS, C.CP_INTR, C.CP_IDLE}
+
+	self.List = make([]Cpu, ncpu)
+	for curcpu := range self.List {
+		sysctlCptime(ncpu, curcpu, &load)
+		fillCpu(&self.List[curcpu], load)
+	}
+
+	return nil
+}
+
+func (self *ProcList) Get() error {
+	return nil
+}
+
+func (self *ProcArgs) Get(pid int) error {
+	return nil
+}
+
+func (self *ProcEnv) Get(pid int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *ProcState) Get(pid int) error {
+	return nil
+}
+
+func (self *ProcMem) Get(pid int) error {
+	return nil
+}
+
+func (self *ProcTime) Get(pid int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *ProcExe) Get(pid int) error {
+	return nil
+}
+
+func (self *ProcFDUsage) Get(pid int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func fillCpu(cpu *Cpu, load [C.CPUSTATES]C.long) {
+	cpu.User = uint64(load[0])
+	cpu.Nice = uint64(load[1])
+	cpu.Sys = uint64(load[2])
+	cpu.Irq = uint64(load[3])
+	cpu.Idle = uint64(load[4])
+}
+
+func sysctlCptime(ncpu int, curcpu int, load *[C.CPUSTATES]C.long) error {
+	var mib []int32
+
+	// Use the correct mib based on the number of CPUs and fill out the
+	// current CPU number in case of SMP. (0 indexed cf. self.List)
+	if ncpu == 0 {
+		mib = []int32{C.CTL_KERN, C.KERN_CPTIME}
+	} else {
+		mib = []int32{C.CTL_KERN, C.KERN_CPTIME2, int32(curcpu)}
+	}
+
+	len := len(mib)
+
+	n := uintptr(0)
+	// First we determine how much memory we'll need to pass later on (via `n`)
+	_, _, errno := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), uintptr(len), 0, uintptr(unsafe.Pointer(&n)), 0, 0)
+	if errno != 0 || n == 0 {
+		return nil
+	}
+
+	_, _, errno = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), uintptr(len), uintptr(unsafe.Pointer(load)), uintptr(unsafe.Pointer(&n)), 0, 0)
+	if errno != 0 || n == 0 {
+		return nil
+	}
+
+	return nil
+}

vendor/github.com/elastic/gosigar/sigar_stub.go

@@ -0,0 +1,71 @@
+// +build !darwin,!freebsd,!linux,!openbsd,!windows
+
+package gosigar
+
+import (
+	"runtime"
+)
+
+func (c *Cpu) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (l *LoadAverage) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (m *Mem) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (s *Swap) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (f *FDUsage) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (p *ProcTime) Get(int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *FileSystemUsage) Get(path string) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *CpuList) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (p *ProcState) Get(int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (p *ProcExe) Get(int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (p *ProcMem) Get(int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (p *ProcFDUsage) Get(int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (p *ProcEnv) Get(int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (p *ProcList) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (p *ProcArgs) Get(int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *Rusage) Get(int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}

vendor/github.com/elastic/gosigar/sigar_unix.go

@@ -0,0 +1,69 @@
+// Copyright (c) 2012 VMware, Inc.
+
+// +build darwin freebsd linux
+
+package gosigar
+
+import (
+	"syscall"
+	"time"
+
+	"golang.org/x/sys/unix"
+)
+
+func (self *FileSystemUsage) Get(path string) error {
+	stat := syscall.Statfs_t{}
+	err := syscall.Statfs(path, &stat)
+	if err != nil {
+		return err
+	}
+
+	self.Total = uint64(stat.Blocks) * uint64(stat.Bsize)
+	self.Free = uint64(stat.Bfree) * uint64(stat.Bsize)
+	self.Avail = uint64(stat.Bavail) * uint64(stat.Bsize)
+	self.Used = self.Total - self.Free
+	self.Files = stat.Files
+	self.FreeFiles = uint64(stat.Ffree)
+
+	return nil
+}
+
+func (r *Rusage) Get(who int) error {
+	ru, err := getResourceUsage(who)
+	if err != nil {
+		return err
+	}
+
+	uTime := convertRtimeToDur(ru.Utime)
+	sTime := convertRtimeToDur(ru.Stime)
+
+	r.Utime = uTime
+	r.Stime = sTime
+	r.Maxrss = int64(ru.Maxrss)
+	r.Ixrss = int64(ru.Ixrss)
+	r.Idrss = int64(ru.Idrss)
+	r.Isrss = int64(ru.Isrss)
+	r.Minflt = int64(ru.Minflt)
+	r.Majflt = int64(ru.Majflt)
+	r.Nswap = int64(ru.Nswap)
+	r.Inblock = int64(ru.Inblock)
+	r.Oublock = int64(ru.Oublock)
+	r.Msgsnd = int64(ru.Msgsnd)
+	r.Msgrcv = int64(ru.Msgrcv)
+	r.Nsignals = int64(ru.Nsignals)
+	r.Nvcsw = int64(ru.Nvcsw)
+	r.Nivcsw = int64(ru.Nivcsw)
+
+	return nil
+}
+
+func getResourceUsage(who int) (unix.Rusage, error) {
+	r := unix.Rusage{}
+	err := unix.Getrusage(who, &r)
+
+	return r, err
+}
+
+func convertRtimeToDur(t unix.Timeval) time.Duration {
+	return time.Duration(t.Nano())
+}

vendor/github.com/elastic/gosigar/sigar_util.go

@@ -0,0 +1,22 @@
+// Copyright (c) 2012 VMware, Inc.
+
+package gosigar
+
+import (
+	"unsafe"
+)
+
+func bytePtrToString(ptr *int8) string {
+	bytes := (*[10000]byte)(unsafe.Pointer(ptr))
+
+	n := 0
+	for bytes[n] != 0 {
+		n++
+	}
+
+	return string(bytes[0:n])
+}
+
+func chop(buf []byte) []byte {
+	return buf[0 : len(buf)-1]
+}

vendor/github.com/elastic/gosigar/sigar_windows.go

@@ -0,0 +1,437 @@
+// Copyright (c) 2012 VMware, Inc.
+
+package gosigar
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+
+	"github.com/StackExchange/wmi"
+	"github.com/elastic/gosigar/sys/windows"
+	"github.com/pkg/errors"
+)
+
+// Win32_Process represents a process on the Windows operating system. If
+// additional fields are added here (that match the Windows struct) they will
+// automatically be populated when calling getWin32Process.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa394372(v=vs.85).aspx
+type Win32_Process struct {
+	CommandLine string
+}
+
+// Win32_OperatingSystem WMI class represents a Windows-based operating system
+// installed on a computer.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa394239(v=vs.85).aspx
+type Win32_OperatingSystem struct {
+	LastBootUpTime time.Time
+}
+
+var (
+	// version is Windows version of the host OS.
+	version = windows.GetWindowsVersion()
+
+	// processQueryLimitedInfoAccess is set to PROCESS_QUERY_INFORMATION for Windows
+	// 2003 and XP where PROCESS_QUERY_LIMITED_INFORMATION is unknown. For all newer
+	// OS versions it is set to PROCESS_QUERY_LIMITED_INFORMATION.
+	processQueryLimitedInfoAccess = windows.PROCESS_QUERY_LIMITED_INFORMATION
+
+	// bootTime is the time when the OS was last booted. This value may be nil
+	// on operating systems that do not support the WMI query used to obtain it.
+	bootTime     *time.Time
+	bootTimeLock sync.Mutex
+)
+
+func init() {
+	if !version.IsWindowsVistaOrGreater() {
+		// PROCESS_QUERY_LIMITED_INFORMATION cannot be used on 2003 or XP.
+		processQueryLimitedInfoAccess = syscall.PROCESS_QUERY_INFORMATION
+	}
+}
+
+func (self *LoadAverage) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *FDUsage) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *ProcEnv) Get(pid int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *ProcExe) Get(pid int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *ProcFDUsage) Get(pid int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *Uptime) Get() error {
+	// Minimum supported OS is Windows Vista.
+	if !version.IsWindowsVistaOrGreater() {
+		return ErrNotImplemented{runtime.GOOS}
+	}
+
+	bootTimeLock.Lock()
+	defer bootTimeLock.Unlock()
+	if bootTime == nil {
+		os, err := getWin32OperatingSystem()
+		if err != nil {
+			return errors.Wrap(err, "failed to get boot time using WMI")
+		}
+		bootTime = &os.LastBootUpTime
+	}
+
+	self.Length = time.Since(*bootTime).Seconds()
+	return nil
+}
+
+func (self *Mem) Get() error {
+	memoryStatusEx, err := windows.GlobalMemoryStatusEx()
+	if err != nil {
+		return errors.Wrap(err, "GlobalMemoryStatusEx failed")
+	}
+
+	self.Total = memoryStatusEx.TotalPhys
+	self.Free = memoryStatusEx.AvailPhys
+	self.Used = self.Total - self.Free
+	self.ActualFree = self.Free
+	self.ActualUsed = self.Used
+	return nil
+}
+
+func (self *Swap) Get() error {
+	memoryStatusEx, err := windows.GlobalMemoryStatusEx()
+	if err != nil {
+		return errors.Wrap(err, "GlobalMemoryStatusEx failed")
+	}
+
+	self.Total = memoryStatusEx.TotalPageFile
+	self.Free = memoryStatusEx.AvailPageFile
+	self.Used = self.Total - self.Free
+	return nil
+}
+
+func (self *Cpu) Get() error {
+	idle, kernel, user, err := windows.GetSystemTimes()
+	if err != nil {
+		return errors.Wrap(err, "GetSystemTimes failed")
+	}
+
+	// CPU times are reported in milliseconds by gosigar.
+	self.Idle = uint64(idle / time.Millisecond)
+	self.Sys = uint64(kernel / time.Millisecond)
+	self.User = uint64(user / time.Millisecond)
+	return nil
+}
+
+func (self *CpuList) Get() error {
+	cpus, err := windows.NtQuerySystemProcessorPerformanceInformation()
+	if err != nil {
+		return errors.Wrap(err, "NtQuerySystemProcessorPerformanceInformation failed")
+	}
+
+	self.List = make([]Cpu, 0, len(cpus))
+	for _, cpu := range cpus {
+		self.List = append(self.List, Cpu{
+			Idle: uint64(cpu.IdleTime / time.Millisecond),
+			Sys:  uint64(cpu.KernelTime / time.Millisecond),
+			User: uint64(cpu.UserTime / time.Millisecond),
+		})
+	}
+	return nil
+}
+
+func (self *FileSystemList) Get() error {
+	drives, err := windows.GetLogicalDriveStrings()
+	if err != nil {
+		return errors.Wrap(err, "GetLogicalDriveStrings failed")
+	}
+
+	for _, drive := range drives {
+		dt, err := windows.GetDriveType(drive)
+		if err != nil {
+			return errors.Wrapf(err, "GetDriveType failed")
+		}
+
+		self.List = append(self.List, FileSystem{
+			DirName:  drive,
+			DevName:  drive,
+			TypeName: dt.String(),
+		})
+	}
+	return nil
+}
+
+// Get retrieves a list of all process identifiers (PIDs) in the system.
+func (self *ProcList) Get() error {
+	pids, err := windows.EnumProcesses()
+	if err != nil {
+		return errors.Wrap(err, "EnumProcesses failed")
+	}
+
+	// Convert uint32 PIDs to int.
+	self.List = make([]int, 0, len(pids))
+	for _, pid := range pids {
+		self.List = append(self.List, int(pid))
+	}
+	return nil
+}
+
+func (self *ProcState) Get(pid int) error {
+	var errs []error
+
+	var err error
+	self.Name, err = getProcName(pid)
+	if err != nil {
+		errs = append(errs, errors.Wrap(err, "getProcName failed"))
+	}
+
+	self.State, err = getProcStatus(pid)
+	if err != nil {
+		errs = append(errs, errors.Wrap(err, "getProcStatus failed"))
+	}
+
+	self.Ppid, err = getParentPid(pid)
+	if err != nil {
+		errs = append(errs, errors.Wrap(err, "getParentPid failed"))
+	}
+
+	self.Username, err = getProcCredName(pid)
+	if err != nil {
+		errs = append(errs, errors.Wrap(err, "getProcCredName failed"))
+	}
+
+	if len(errs) > 0 {
+		errStrs := make([]string, 0, len(errs))
+		for _, e := range errs {
+			errStrs = append(errStrs, e.Error())
+		}
+		return errors.New(strings.Join(errStrs, "; "))
+	}
+	return nil
+}
+
+// getProcName returns the process name associated with the PID.
+func getProcName(pid int) (string, error) {
+	handle, err := syscall.OpenProcess(processQueryLimitedInfoAccess, false, uint32(pid))
+	if err != nil {
+		return "", errors.Wrapf(err, "OpenProcess failed for pid=%v", pid)
+	}
+	defer syscall.CloseHandle(handle)
+
+	filename, err := windows.GetProcessImageFileName(handle)
+	if err != nil {
+		return "", errors.Wrapf(err, "GetProcessImageFileName failed for pid=%v", pid)
+	}
+
+	return filepath.Base(filename), nil
+}
+
+// getProcStatus returns the status of a process.
+func getProcStatus(pid int) (RunState, error) {
+	handle, err := syscall.OpenProcess(processQueryLimitedInfoAccess, false, uint32(pid))
+	if err != nil {
+		return RunStateUnknown, errors.Wrapf(err, "OpenProcess failed for pid=%v", pid)
+	}
+	defer syscall.CloseHandle(handle)
+
+	var exitCode uint32
+	err = syscall.GetExitCodeProcess(handle, &exitCode)
+	if err != nil {
+		return RunStateUnknown, errors.Wrapf(err, "GetExitCodeProcess failed for pid=%v")
+	}
+
+	if exitCode == 259 { //still active
+		return RunStateRun, nil
+	}
+	return RunStateSleep, nil
+}
+
+// getParentPid returns the parent process ID of a process.
+func getParentPid(pid int) (int, error) {
+	handle, err := syscall.OpenProcess(processQueryLimitedInfoAccess, false, uint32(pid))
+	if err != nil {
+		return RunStateUnknown, errors.Wrapf(err, "OpenProcess failed for pid=%v", pid)
+	}
+	defer syscall.CloseHandle(handle)
+
+	procInfo, err := windows.NtQueryProcessBasicInformation(handle)
+	if err != nil {
+		return 0, errors.Wrapf(err, "NtQueryProcessBasicInformation failed for pid=%v", pid)
+	}
+
+	return int(procInfo.InheritedFromUniqueProcessID), nil
+}
+
+func getProcCredName(pid int) (string, error) {
+	handle, err := syscall.OpenProcess(syscall.PROCESS_QUERY_INFORMATION, false, uint32(pid))
+	if err != nil {
+		return "", errors.Wrapf(err, "OpenProcess failed for pid=%v", pid)
+	}
+	defer syscall.CloseHandle(handle)
+
+	// Find process token via win32.
+	var token syscall.Token
+	err = syscall.OpenProcessToken(handle, syscall.TOKEN_QUERY, &token)
+	if err != nil {
+		return "", errors.Wrapf(err, "OpenProcessToken failed for pid=%v", pid)
+	}
+
+	// Find the token user.
+	tokenUser, err := token.GetTokenUser()
+	if err != nil {
+		return "", errors.Wrapf(err, "GetTokenInformation failed for pid=%v", pid)
+	}
+
+	// Close token to prevent handle leaks.
+	err = token.Close()
+	if err != nil {
+		return "", errors.Wrapf(err, "failed while closing process token handle for pid=%v", pid)
+	}
+
+	// Look up domain account by SID.
+	account, domain, _, err := tokenUser.User.Sid.LookupAccount("")
+	if err != nil {
+		sid, sidErr := tokenUser.User.Sid.String()
+		if sidErr != nil {
+			return "", errors.Wrapf(err, "failed while looking up account name for pid=%v", pid)
+		}
+		return "", errors.Wrapf(err, "failed while looking up account name for SID=%v of pid=%v", sid, pid)
+	}
+
+	return fmt.Sprintf(`%s\%s`, domain, account), nil
+}
+
+func (self *ProcMem) Get(pid int) error {
+	handle, err := syscall.OpenProcess(processQueryLimitedInfoAccess|windows.PROCESS_VM_READ, false, uint32(pid))
+	if err != nil {
+		return errors.Wrapf(err, "OpenProcess failed for pid=%v", pid)
+	}
+	defer syscall.CloseHandle(handle)
+
+	counters, err := windows.GetProcessMemoryInfo(handle)
+	if err != nil {
+		return errors.Wrapf(err, "GetProcessMemoryInfo failed for pid=%v", pid)
+	}
+
+	self.Resident = uint64(counters.WorkingSetSize)
+	self.Size = uint64(counters.PrivateUsage)
+	return nil
+}
+
+func (self *ProcTime) Get(pid int) error {
+	cpu, err := getProcTimes(pid)
+	if err != nil {
+		return err
+	}
+
+	// Windows epoch times are expressed as time elapsed since midnight on
+	// January 1, 1601 at Greenwich, England. This converts the Filetime to
+	// unix epoch in milliseconds.
+	self.StartTime = uint64(cpu.CreationTime.Nanoseconds() / 1e6)
+
+	// Convert to millis.
+	self.User = uint64(windows.FiletimeToDuration(&cpu.UserTime).Nanoseconds() / 1e6)
+	self.Sys = uint64(windows.FiletimeToDuration(&cpu.KernelTime).Nanoseconds() / 1e6)
+	self.Total = self.User + self.Sys
+
+	return nil
+}
+
+func getProcTimes(pid int) (*syscall.Rusage, error) {
+	handle, err := syscall.OpenProcess(processQueryLimitedInfoAccess, false, uint32(pid))
+	if err != nil {
+		return nil, errors.Wrapf(err, "OpenProcess failed for pid=%v", pid)
+	}
+	defer syscall.CloseHandle(handle)
+
+	var cpu syscall.Rusage
+	if err := syscall.GetProcessTimes(handle, &cpu.CreationTime, &cpu.ExitTime, &cpu.KernelTime, &cpu.UserTime); err != nil {
+		return nil, errors.Wrapf(err, "GetProcessTimes failed for pid=%v", pid)
+	}
+
+	return &cpu, nil
+}
+
+func (self *ProcArgs) Get(pid int) error {
+	// The minimum supported client for Win32_Process is Windows Vista.
+	if !version.IsWindowsVistaOrGreater() {
+		return ErrNotImplemented{runtime.GOOS}
+	}
+
+	process, err := getWin32Process(int32(pid))
+	if err != nil {
+		return errors.Wrapf(err, "ProcArgs failed for pid=%v", pid)
+	}
+
+	self.List = []string{process.CommandLine}
+	return nil
+}
+
+func (self *FileSystemUsage) Get(path string) error {
+	freeBytesAvailable, totalNumberOfBytes, totalNumberOfFreeBytes, err := windows.GetDiskFreeSpaceEx(path)
+	if err != nil {
+		return errors.Wrap(err, "GetDiskFreeSpaceEx failed")
+	}
+
+	self.Total = totalNumberOfBytes
+	self.Free = totalNumberOfFreeBytes
+	self.Used = self.Total - self.Free
+	self.Avail = freeBytesAvailable
+	return nil
+}
+
+// getWin32Process gets information about the process with the given process ID.
+// It uses a WMI query to get the information from the local system.
+func getWin32Process(pid int32) (Win32_Process, error) {
+	var dst []Win32_Process
+	query := fmt.Sprintf("WHERE ProcessId = %d", pid)
+	q := wmi.CreateQuery(&dst, query)
+	err := wmi.Query(q, &dst)
+	if err != nil {
+		return Win32_Process{}, fmt.Errorf("could not get Win32_Process %s: %v", query, err)
+	}
+	if len(dst) < 1 {
+		return Win32_Process{}, fmt.Errorf("could not get Win32_Process %s: Process not found", query)
+	}
+	return dst[0], nil
+}
+
+func getWin32OperatingSystem() (Win32_OperatingSystem, error) {
+	var dst []Win32_OperatingSystem
+	q := wmi.CreateQuery(&dst, "")
+	err := wmi.Query(q, &dst)
+	if err != nil {
+		return Win32_OperatingSystem{}, errors.Wrap(err, "wmi query for Win32_OperatingSystem failed")
+	}
+	if len(dst) != 1 {
+		return Win32_OperatingSystem{}, errors.New("wmi query for Win32_OperatingSystem failed")
+	}
+	return dst[0], nil
+}
+
+func (self *Rusage) Get(who int) error {
+	if who != 0 {
+		return ErrNotImplemented{runtime.GOOS}
+	}
+
+	pid := os.Getpid()
+	cpu, err := getProcTimes(pid)
+	if err != nil {
+		return err
+	}
+
+	self.Utime = windows.FiletimeToDuration(&cpu.UserTime)
+	self.Stime = windows.FiletimeToDuration(&cpu.KernelTime)
+
+	return nil
+}

vendor/github.com/elastic/gosigar/sys/windows/doc.go

@@ -0,0 +1,2 @@
+// Package windows contains various Windows system call.
+package windows

vendor/github.com/elastic/gosigar/sys/windows/ntquery.go

@@ -0,0 +1,132 @@
+// +build windows
+
+package windows
+
+import (
+	"bytes"
+	"encoding/binary"
+	"io"
+	"runtime"
+	"syscall"
+	"time"
+	"unsafe"
+
+	"github.com/pkg/errors"
+)
+
+// On both 32-bit and 64-bit systems NtQuerySystemInformation expects the
+// size of SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION to be 48.
+const sizeofSystemProcessorPerformanceInformation = 48
+
+// ProcessBasicInformation is an equivalent representation of
+// PROCESS_BASIC_INFORMATION in the Windows API.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms684280(v=vs.85).aspx
+type ProcessBasicInformation struct {
+	ExitStatus                   uint
+	PebBaseAddress               uintptr
+	AffinityMask                 uint
+	BasePriority                 uint
+	UniqueProcessID              uint
+	InheritedFromUniqueProcessID uint
+}
+
+// NtQueryProcessBasicInformation queries basic information about the process
+// associated with the given handle (provided by OpenProcess). It uses the
+// NtQueryInformationProcess function to collect the data.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms684280(v=vs.85).aspx
+func NtQueryProcessBasicInformation(handle syscall.Handle) (ProcessBasicInformation, error) {
+	var processBasicInfo ProcessBasicInformation
+	processBasicInfoPtr := (*byte)(unsafe.Pointer(&processBasicInfo))
+	size := uint32(unsafe.Sizeof(processBasicInfo))
+	ntStatus, _ := _NtQueryInformationProcess(handle, 0, processBasicInfoPtr, size, nil)
+	if ntStatus != 0 {
+		return ProcessBasicInformation{}, errors.Errorf("NtQueryInformationProcess failed, NTSTATUS=0x%X", ntStatus)
+	}
+
+	return processBasicInfo, nil
+}
+
+// SystemProcessorPerformanceInformation contains CPU performance information
+// for a single CPU.
+type SystemProcessorPerformanceInformation struct {
+	IdleTime   time.Duration // Amount of time spent idle.
+	KernelTime time.Duration // Kernel time does NOT include time spent in idle.
+	UserTime   time.Duration // Amount of time spent executing in user mode.
+}
+
+// _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION is an equivalent representation of
+// SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION in the Windows API. This struct is
+// used internally with NtQuerySystemInformation call and is not exported. The
+// exported equivalent is SystemProcessorPerformanceInformation.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms724509(v=vs.85).aspx
+type _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION struct {
+	IdleTime   int64
+	KernelTime int64
+	UserTime   int64
+	Reserved1  [2]int64
+	Reserved2  uint32
+}
+
+// NtQuerySystemProcessorPerformanceInformation queries CPU performance
+// information for each CPU. It uses the NtQuerySystemInformation function to
+// collect the SystemProcessorPerformanceInformation.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms724509(v=vs.85).aspx
+func NtQuerySystemProcessorPerformanceInformation() ([]SystemProcessorPerformanceInformation, error) {
+	// NTSTATUS code for success.
+	// https://msdn.microsoft.com/en-us/library/cc704588.aspx
+	const STATUS_SUCCESS = 0
+
+	// From the _SYSTEM_INFORMATION_CLASS enum.
+	// http://processhacker.sourceforge.net/doc/ntexapi_8h.html#ad5d815b48e8f4da1ef2eb7a2f18a54e0
+	const systemProcessorPerformanceInformation = 8
+
+	// Create a buffer large enough to hold an entry for each processor.
+	b := make([]byte, runtime.NumCPU()*sizeofSystemProcessorPerformanceInformation)
+
+	// Query the performance information. Note that this function uses 0 to
+	// indicate success. Most other Windows functions use non-zero for success.
+	var returnLength uint32
+	ntStatus, _ := _NtQuerySystemInformation(systemProcessorPerformanceInformation, &b[0], uint32(len(b)), &returnLength)
+	if ntStatus != STATUS_SUCCESS {
+		return nil, errors.Errorf("NtQuerySystemInformation failed, NTSTATUS=0x%X, bufLength=%v, returnLength=%v", ntStatus, len(b), returnLength)
+	}
+
+	return readSystemProcessorPerformanceInformationBuffer(b)
+}
+
+// readSystemProcessorPerformanceInformationBuffer reads from a buffer
+// containing SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION data. The buffer should
+// contain one entry for each CPU.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms724509(v=vs.85).aspx
+func readSystemProcessorPerformanceInformationBuffer(b []byte) ([]SystemProcessorPerformanceInformation, error) {
+	n := len(b) / sizeofSystemProcessorPerformanceInformation
+	r := bytes.NewReader(b)
+
+	rtn := make([]SystemProcessorPerformanceInformation, 0, n)
+	for i := 0; i < n; i++ {
+		_, err := r.Seek(int64(i*sizeofSystemProcessorPerformanceInformation), io.SeekStart)
+		if err != nil {
+			return nil, errors.Wrapf(err, "failed to seek to cpuN=%v in buffer", i)
+		}
+
+		times := make([]uint64, 3)
+		for j := range times {
+			err := binary.Read(r, binary.LittleEndian, &times[j])
+			if err != nil {
+				return nil, errors.Wrapf(err, "failed reading cpu times for cpuN=%v", i)
+			}
+		}
+
+		idleTime := time.Duration(times[0] * 100)
+		kernelTime := time.Duration(times[1] * 100)
+		userTime := time.Duration(times[2] * 100)
+
+		rtn = append(rtn, SystemProcessorPerformanceInformation{
+			IdleTime:   idleTime,
+			KernelTime: kernelTime - idleTime, // Subtract out idle time from kernel time.
+			UserTime:   userTime,
+		})
+	}
+
+	return rtn, nil
+}

vendor/github.com/elastic/gosigar/sys/windows/privileges.go

@@ -0,0 +1,272 @@
+// +build windows
+
+package windows
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/json"
+	"fmt"
+	"runtime"
+	"strings"
+	"sync"
+	"syscall"
+
+	"github.com/pkg/errors"
+	"golang.org/x/sys/windows"
+)
+
+// Cache of privilege names to LUIDs.
+var (
+	privNames     = make(map[string]int64)
+	privNameMutex sync.Mutex
+)
+
+const (
+	// SeDebugPrivilege is the name of the privilege used to debug programs.
+	SeDebugPrivilege = "SeDebugPrivilege"
+)
+
+// Errors returned by AdjustTokenPrivileges.
+const (
+	ERROR_NOT_ALL_ASSIGNED syscall.Errno = 1300
+)
+
+// Attribute bits for privileges.
+const (
+	_SE_PRIVILEGE_ENABLED_BY_DEFAULT uint32 = 0x00000001
+	_SE_PRIVILEGE_ENABLED            uint32 = 0x00000002
+	_SE_PRIVILEGE_REMOVED            uint32 = 0x00000004
+	_SE_PRIVILEGE_USED_FOR_ACCESS    uint32 = 0x80000000
+)
+
+// Privilege contains information about a single privilege associated with a
+// Token.
+type Privilege struct {
+	LUID             int64  `json:"-"` // Locally unique identifier (guaranteed only until the system is restarted).
+	Name             string `json:"-"`
+	EnabledByDefault bool   `json:"enabled_by_default,omitempty"`
+	Enabled          bool   `json:"enabled"`
+	Removed          bool   `json:"removed,omitempty"`
+	Used             bool   `json:"used,omitempty"`
+}
+
+func (p Privilege) String() string {
+	var buf bytes.Buffer
+	buf.WriteString(p.Name)
+	buf.WriteString("=(")
+
+	opts := make([]string, 0, 4)
+	if p.EnabledByDefault {
+		opts = append(opts, "Default")
+	}
+	if p.Enabled {
+		opts = append(opts, "Enabled")
+	}
+	if !p.EnabledByDefault && !p.Enabled {
+		opts = append(opts, "Disabled")
+	}
+	if p.Removed {
+		opts = append(opts, "Removed")
+	}
+	if p.Used {
+		opts = append(opts, "Used")
+	}
+
+	buf.WriteString(strings.Join(opts, ", "))
+	buf.WriteString(")")
+
+	// Example: SeDebugPrivilege=(Default, Enabled)
+	return buf.String()
+}
+
+// User represent the information about a Windows account.
+type User struct {
+	SID     string
+	Account string
+	Domain  string
+	Type    uint32
+}
+
+func (u User) String() string {
+	return fmt.Sprintf(`User:%v\%v, SID:%v, Type:%v`, u.Domain, u.Account, u.SID, u.Type)
+}
+
+// DebugInfo contains general debug info about the current process.
+type DebugInfo struct {
+	OSVersion    Version              // OS version info.
+	Arch         string               // Architecture of the machine.
+	NumCPU       int                  // Number of CPUs.
+	User         User                 // User that this process is running as.
+	ProcessPrivs map[string]Privilege // Privileges held by the process.
+}
+
+func (d DebugInfo) String() string {
+	bytes, _ := json.Marshal(d)
+	return string(bytes)
+}
+
+// LookupPrivilegeName looks up a privilege name given a LUID value.
+func LookupPrivilegeName(systemName string, luid int64) (string, error) {
+	buf := make([]uint16, 256)
+	bufSize := uint32(len(buf))
+	err := _LookupPrivilegeName(systemName, &luid, &buf[0], &bufSize)
+	if err != nil {
+		return "", errors.Wrapf(err, "LookupPrivilegeName failed for luid=%v", luid)
+	}
+
+	return syscall.UTF16ToString(buf), nil
+}
+
+// mapPrivileges maps privilege names to LUID values.
+func mapPrivileges(names []string) ([]int64, error) {
+	var privileges []int64
+	privNameMutex.Lock()
+	defer privNameMutex.Unlock()
+	for _, name := range names {
+		p, ok := privNames[name]
+		if !ok {
+			err := _LookupPrivilegeValue("", name, &p)
+			if err != nil {
+				return nil, errors.Wrapf(err, "LookupPrivilegeValue failed on '%v'", name)
+			}
+			privNames[name] = p
+		}
+		privileges = append(privileges, p)
+	}
+	return privileges, nil
+}
+
+// EnableTokenPrivileges enables the specified privileges in the given
+// Token. The token must have TOKEN_ADJUST_PRIVILEGES access. If the token
+// does not already contain the privilege it cannot be enabled.
+func EnableTokenPrivileges(token syscall.Token, privileges ...string) error {
+	privValues, err := mapPrivileges(privileges)
+	if err != nil {
+		return err
+	}
+
+	var b bytes.Buffer
+	binary.Write(&b, binary.LittleEndian, uint32(len(privValues)))
+	for _, p := range privValues {
+		binary.Write(&b, binary.LittleEndian, p)
+		binary.Write(&b, binary.LittleEndian, uint32(_SE_PRIVILEGE_ENABLED))
+	}
+
+	success, err := _AdjustTokenPrivileges(token, false, &b.Bytes()[0], uint32(b.Len()), nil, nil)
+	if !success {
+		return err
+	}
+	if err == ERROR_NOT_ALL_ASSIGNED {
+		return errors.Wrap(err, "error not all privileges were assigned")
+	}
+
+	return nil
+}
+
+// GetTokenPrivileges returns a list of privileges associated with a token.
+// The provided token must have at a minimum TOKEN_QUERY access. This is a
+// wrapper around the GetTokenInformation function.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa446671(v=vs.85).aspx
+func GetTokenPrivileges(token syscall.Token) (map[string]Privilege, error) {
+	// Determine the required buffer size.
+	var size uint32
+	syscall.GetTokenInformation(token, syscall.TokenPrivileges, nil, 0, &size)
+
+	// This buffer will receive a TOKEN_PRIVILEGE structure.
+	b := bytes.NewBuffer(make([]byte, size))
+	err := syscall.GetTokenInformation(token, syscall.TokenPrivileges, &b.Bytes()[0], uint32(b.Len()), &size)
+	if err != nil {
+		return nil, errors.Wrap(err, "GetTokenInformation failed")
+	}
+
+	var privilegeCount uint32
+	err = binary.Read(b, binary.LittleEndian, &privilegeCount)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to read PrivilegeCount")
+	}
+
+	rtn := make(map[string]Privilege, privilegeCount)
+	for i := 0; i < int(privilegeCount); i++ {
+		var luid int64
+		err = binary.Read(b, binary.LittleEndian, &luid)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to read LUID value")
+		}
+
+		var attributes uint32
+		err = binary.Read(b, binary.LittleEndian, &attributes)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to read attributes")
+		}
+
+		name, err := LookupPrivilegeName("", luid)
+		if err != nil {
+			return nil, errors.Wrapf(err, "LookupPrivilegeName failed for LUID=%v", luid)
+		}
+
+		rtn[name] = Privilege{
+			LUID:             luid,
+			Name:             name,
+			EnabledByDefault: (attributes & _SE_PRIVILEGE_ENABLED_BY_DEFAULT) > 0,
+			Enabled:          (attributes & _SE_PRIVILEGE_ENABLED) > 0,
+			Removed:          (attributes & _SE_PRIVILEGE_REMOVED) > 0,
+			Used:             (attributes & _SE_PRIVILEGE_USED_FOR_ACCESS) > 0,
+		}
+	}
+
+	return rtn, nil
+}
+
+// GetTokenUser returns the User associated with the given Token.
+func GetTokenUser(token syscall.Token) (User, error) {
+	tokenUser, err := token.GetTokenUser()
+	if err != nil {
+		return User{}, errors.Wrap(err, "GetTokenUser failed")
+	}
+
+	var user User
+	user.SID, err = tokenUser.User.Sid.String()
+	if err != nil {
+		return user, errors.Wrap(err, "ConvertSidToStringSid failed")
+	}
+
+	user.Account, user.Domain, user.Type, err = tokenUser.User.Sid.LookupAccount("")
+	if err != nil {
+		return user, errors.Wrap(err, "LookupAccountSid failed")
+	}
+
+	return user, nil
+}
+
+// GetDebugInfo returns general debug info about the current process.
+func GetDebugInfo() (*DebugInfo, error) {
+	h, err := windows.GetCurrentProcess()
+	if err != nil {
+		return nil, err
+	}
+
+	var token syscall.Token
+	err = syscall.OpenProcessToken(syscall.Handle(h), syscall.TOKEN_QUERY, &token)
+	if err != nil {
+		return nil, err
+	}
+
+	privs, err := GetTokenPrivileges(token)
+	if err != nil {
+		return nil, err
+	}
+
+	user, err := GetTokenUser(token)
+	if err != nil {
+		return nil, err
+	}
+
+	return &DebugInfo{
+		User:         user,
+		ProcessPrivs: privs,
+		OSVersion:    GetWindowsVersion(),
+		Arch:         runtime.GOARCH,
+		NumCPU:       runtime.NumCPU(),
+	}, nil
+}

vendor/github.com/elastic/gosigar/sys/windows/syscall_windows.go

@@ -0,0 +1,385 @@
+package windows
+
+import (
+	"fmt"
+	"syscall"
+	"time"
+	"unsafe"
+
+	"github.com/pkg/errors"
+)
+
+var (
+	sizeofUint32                  = 4
+	sizeofProcessEntry32          = uint32(unsafe.Sizeof(ProcessEntry32{}))
+	sizeofProcessMemoryCountersEx = uint32(unsafe.Sizeof(ProcessMemoryCountersEx{}))
+	sizeofMemoryStatusEx          = uint32(unsafe.Sizeof(MemoryStatusEx{}))
+)
+
+// Process-specific access rights. Others are declared in the syscall package.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms684880(v=vs.85).aspx
+const (
+	PROCESS_QUERY_LIMITED_INFORMATION uint32 = 0x1000
+	PROCESS_VM_READ                   uint32 = 0x0010
+)
+
+// MAX_PATH is the maximum length for a path in Windows.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx
+const MAX_PATH = 260
+
+// DriveType represents a type of drive (removable, fixed, CD-ROM, RAM disk, or
+// network drive).
+type DriveType uint32
+
+// Drive types as returned by GetDriveType.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa364939(v=vs.85).aspx
+const (
+	DRIVE_UNKNOWN DriveType = iota
+	DRIVE_NO_ROOT_DIR
+	DRIVE_REMOVABLE
+	DRIVE_FIXED
+	DRIVE_REMOTE
+	DRIVE_CDROM
+	DRIVE_RAMDISK
+)
+
+func (dt DriveType) String() string {
+	names := map[DriveType]string{
+		DRIVE_UNKNOWN:     "unknown",
+		DRIVE_NO_ROOT_DIR: "invalid",
+		DRIVE_REMOVABLE:   "removable",
+		DRIVE_FIXED:       "fixed",
+		DRIVE_REMOTE:      "remote",
+		DRIVE_CDROM:       "cdrom",
+		DRIVE_RAMDISK:     "ramdisk",
+	}
+
+	name, found := names[dt]
+	if !found {
+		return "unknown DriveType value"
+	}
+	return name
+}
+
+// Flags that can be used with CreateToolhelp32Snapshot.
+const (
+	TH32CS_INHERIT      uint32 = 0x80000000 // Indicates that the snapshot handle is to be inheritable.
+	TH32CS_SNAPHEAPLIST uint32 = 0x00000001 // Includes all heaps of the process specified in th32ProcessID in the snapshot.
+	TH32CS_SNAPMODULE   uint32 = 0x00000008 // Includes all modules of the process specified in th32ProcessID in the snapshot.
+	TH32CS_SNAPMODULE32 uint32 = 0x00000010 // Includes all 32-bit modules of the process specified in th32ProcessID in the snapshot when called from a 64-bit process.
+	TH32CS_SNAPPROCESS  uint32 = 0x00000002 // Includes all processes in the system in the snapshot.
+	TH32CS_SNAPTHREAD   uint32 = 0x00000004 // Includes all threads in the system in the snapshot.
+)
+
+// ProcessEntry32 is an equivalent representation of PROCESSENTRY32 in the
+// Windows API. It contains a process's information. Do not modify or reorder.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms684839(v=vs.85).aspx
+type ProcessEntry32 struct {
+	size              uint32
+	CntUsage          uint32
+	ProcessID         uint32
+	DefaultHeapID     uintptr
+	ModuleID          uint32
+	CntThreads        uint32
+	ParentProcessID   uint32
+	PriorityClassBase int32
+	Flags             uint32
+	exeFile           [MAX_PATH]uint16
+}
+
+// ExeFile returns the name of the executable file for the process. It does
+// not contain the full path.
+func (p ProcessEntry32) ExeFile() string {
+	return syscall.UTF16ToString(p.exeFile[:])
+}
+
+func (p ProcessEntry32) String() string {
+	return fmt.Sprintf("{CntUsage:%v ProcessID:%v DefaultHeapID:%v ModuleID:%v "+
+		"CntThreads:%v ParentProcessID:%v PriorityClassBase:%v Flags:%v ExeFile:%v",
+		p.CntUsage, p.ProcessID, p.DefaultHeapID, p.ModuleID, p.CntThreads,
+		p.ParentProcessID, p.PriorityClassBase, p.Flags, p.ExeFile())
+}
+
+// MemoryStatusEx is an equivalent representation of MEMORYSTATUSEX in the
+// Windows API. It contains information about the current state of both physical
+// and virtual memory, including extended memory.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa366770
+type MemoryStatusEx struct {
+	length               uint32
+	MemoryLoad           uint32
+	TotalPhys            uint64
+	AvailPhys            uint64
+	TotalPageFile        uint64
+	AvailPageFile        uint64
+	TotalVirtual         uint64
+	AvailVirtual         uint64
+	AvailExtendedVirtual uint64
+}
+
+// ProcessMemoryCountersEx is an equivalent representation of
+// PROCESS_MEMORY_COUNTERS_EX in the Windows API.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms684874(v=vs.85).aspx
+type ProcessMemoryCountersEx struct {
+	cb                         uint32
+	PageFaultCount             uint32
+	PeakWorkingSetSize         uintptr
+	WorkingSetSize             uintptr
+	QuotaPeakPagedPoolUsage    uintptr
+	QuotaPagedPoolUsage        uintptr
+	QuotaPeakNonPagedPoolUsage uintptr
+	QuotaNonPagedPoolUsage     uintptr
+	PagefileUsage              uintptr
+	PeakPagefileUsage          uintptr
+	PrivateUsage               uintptr
+}
+
+// GetLogicalDriveStrings returns a list of drives in the system.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa364975(v=vs.85).aspx
+func GetLogicalDriveStrings() ([]string, error) {
+	// Determine the size of the buffer required to receive all drives.
+	bufferLength, err := _GetLogicalDriveStringsW(0, nil)
+	if err != nil {
+		return nil, errors.Wrap(err, "GetLogicalDriveStringsW failed to get buffer length")
+	}
+	if bufferLength < 0 {
+		return nil, errors.New("GetLogicalDriveStringsW returned an invalid buffer length")
+	}
+
+	buffer := make([]uint16, bufferLength)
+	_, err = _GetLogicalDriveStringsW(uint32(len(buffer)), &buffer[0])
+	if err != nil {
+		return nil, errors.Wrap(err, "GetLogicalDriveStringsW failed")
+	}
+
+	// Split the uint16 slice at null-terminators.
+	var startIdx int
+	var drivesUTF16 [][]uint16
+	for i, value := range buffer {
+		if value == 0 {
+			drivesUTF16 = append(drivesUTF16, buffer[startIdx:i])
+			startIdx = i + 1
+		}
+	}
+
+	// Convert the utf16 slices to strings.
+	drives := make([]string, 0, len(drivesUTF16))
+	for _, driveUTF16 := range drivesUTF16 {
+		if len(driveUTF16) > 0 {
+			drives = append(drives, syscall.UTF16ToString(driveUTF16))
+		}
+	}
+
+	return drives, nil
+}
+
+// GlobalMemoryStatusEx retrieves information about the system's current usage
+// of both physical and virtual memory.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa366589(v=vs.85).aspx
+func GlobalMemoryStatusEx() (MemoryStatusEx, error) {
+	memoryStatusEx := MemoryStatusEx{length: sizeofMemoryStatusEx}
+	err := _GlobalMemoryStatusEx(&memoryStatusEx)
+	if err != nil {
+		return MemoryStatusEx{}, errors.Wrap(err, "GlobalMemoryStatusEx failed")
+	}
+
+	return memoryStatusEx, nil
+}
+
+// GetProcessMemoryInfo retrieves information about the memory usage of the
+// specified process.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms683219(v=vs.85).aspx
+func GetProcessMemoryInfo(handle syscall.Handle) (ProcessMemoryCountersEx, error) {
+	processMemoryCountersEx := ProcessMemoryCountersEx{cb: sizeofProcessMemoryCountersEx}
+	err := _GetProcessMemoryInfo(handle, &processMemoryCountersEx, processMemoryCountersEx.cb)
+	if err != nil {
+		return ProcessMemoryCountersEx{}, errors.Wrap(err, "GetProcessMemoryInfo failed")
+	}
+
+	return processMemoryCountersEx, nil
+}
+
+// GetProcessImageFileName Retrieves the name of the executable file for the
+// specified process.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms683217(v=vs.85).aspx
+func GetProcessImageFileName(handle syscall.Handle) (string, error) {
+	buffer := make([]uint16, MAX_PATH)
+	_, err := _GetProcessImageFileName(handle, &buffer[0], uint32(len(buffer)))
+	if err != nil {
+		return "", errors.Wrap(err, "GetProcessImageFileName failed")
+	}
+
+	return syscall.UTF16ToString(buffer), nil
+}
+
+// GetSystemTimes retrieves system timing information. On a multiprocessor
+// system, the values returned are the sum of the designated times across all
+// processors. The returned kernel time does not include the system idle time.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms724400(v=vs.85).aspx
+func GetSystemTimes() (idle, kernel, user time.Duration, err error) {
+	var idleTime, kernelTime, userTime syscall.Filetime
+	err = _GetSystemTimes(&idleTime, &kernelTime, &userTime)
+	if err != nil {
+		return 0, 0, 0, errors.Wrap(err, "GetSystemTimes failed")
+	}
+
+	idle = FiletimeToDuration(&idleTime)
+	kernel = FiletimeToDuration(&kernelTime) // Kernel time includes idle time so we subtract it out.
+	user = FiletimeToDuration(&userTime)
+
+	return idle, kernel - idle, user, nil
+}
+
+// FiletimeToDuration converts a Filetime to a time.Duration. Do not use this
+// method to convert a Filetime to an actual clock time, for that use
+// Filetime.Nanosecond().
+func FiletimeToDuration(ft *syscall.Filetime) time.Duration {
+	n := int64(ft.HighDateTime)<<32 + int64(ft.LowDateTime) // in 100-nanosecond intervals
+	return time.Duration(n * 100)
+}
+
+// GetDriveType Determines whether a disk drive is a removable, fixed, CD-ROM,
+// RAM disk, or network drive. A trailing backslash is required on the
+// rootPathName.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa364939
+func GetDriveType(rootPathName string) (DriveType, error) {
+	rootPathNamePtr, err := syscall.UTF16PtrFromString(rootPathName)
+	if err != nil {
+		return DRIVE_UNKNOWN, errors.Wrapf(err, "UTF16PtrFromString failed for rootPathName=%v", rootPathName)
+	}
+
+	dt, err := _GetDriveType(rootPathNamePtr)
+	if err != nil {
+		return DRIVE_UNKNOWN, errors.Wrapf(err, "GetDriveType failed for rootPathName=%v", rootPathName)
+	}
+
+	return dt, nil
+}
+
+// EnumProcesses retrieves the process identifier for each process object in the
+// system. This function can return a max of 65536 PIDs. If there are more
+// processes than that then this will not return them all.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms682629(v=vs.85).aspx
+func EnumProcesses() ([]uint32, error) {
+	enumProcesses := func(size int) ([]uint32, error) {
+		var (
+			pids         = make([]uint32, size)
+			sizeBytes    = len(pids) * sizeofUint32
+			bytesWritten uint32
+		)
+
+		err := _EnumProcesses(&pids[0], uint32(sizeBytes), &bytesWritten)
+
+		pidsWritten := int(bytesWritten) / sizeofUint32
+		if int(bytesWritten)%sizeofUint32 != 0 || pidsWritten > len(pids) {
+			return nil, errors.Errorf("EnumProcesses returned an invalid bytesWritten value of %v", bytesWritten)
+		}
+		pids = pids[:pidsWritten]
+
+		return pids, err
+	}
+
+	// Retry the EnumProcesses call with larger arrays if needed.
+	size := 2048
+	var pids []uint32
+	for tries := 0; tries < 5; tries++ {
+		var err error
+		pids, err = enumProcesses(size)
+		if err != nil {
+			return nil, errors.Wrap(err, "EnumProcesses failed")
+		}
+
+		if len(pids) < size {
+			break
+		}
+
+		// Increase the size the pids array and retry the enumProcesses call
+		// because the array wasn't large enough to hold all of the processes.
+		size *= 2
+	}
+
+	return pids, nil
+}
+
+// GetDiskFreeSpaceEx retrieves information about the amount of space that is
+// available on a disk volume, which is the total amount of space, the total
+// amount of free space, and the total amount of free space available to the
+// user that is associated with the calling thread.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa364937(v=vs.85).aspx
+func GetDiskFreeSpaceEx(directoryName string) (freeBytesAvailable, totalNumberOfBytes, totalNumberOfFreeBytes uint64, err error) {
+	directoryNamePtr, err := syscall.UTF16PtrFromString(directoryName)
+	if err != nil {
+		return 0, 0, 0, errors.Wrapf(err, "UTF16PtrFromString failed for directoryName=%v", directoryName)
+	}
+
+	err = _GetDiskFreeSpaceEx(directoryNamePtr, &freeBytesAvailable, &totalNumberOfBytes, &totalNumberOfFreeBytes)
+	if err != nil {
+		return 0, 0, 0, err
+	}
+
+	return freeBytesAvailable, totalNumberOfBytes, totalNumberOfFreeBytes, nil
+}
+
+// CreateToolhelp32Snapshot takes a snapshot of the specified processes, as well
+// as the heaps, modules, and threads used by these processes.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms682489(v=vs.85).aspx
+func CreateToolhelp32Snapshot(flags, pid uint32) (syscall.Handle, error) {
+	h, err := _CreateToolhelp32Snapshot(flags, pid)
+	if err != nil {
+		return syscall.InvalidHandle, err
+	}
+	if h == syscall.InvalidHandle {
+		return syscall.InvalidHandle, syscall.GetLastError()
+	}
+
+	return h, nil
+}
+
+// Process32First retrieves information about the first process encountered in a
+// system snapshot.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms684834
+func Process32First(handle syscall.Handle) (ProcessEntry32, error) {
+	processEntry32 := ProcessEntry32{size: sizeofProcessEntry32}
+	err := _Process32First(handle, &processEntry32)
+	if err != nil {
+		return ProcessEntry32{}, errors.Wrap(err, "Process32First failed")
+	}
+
+	return processEntry32, nil
+}
+
+// Process32Next retrieves information about the next process recorded in a
+// system snapshot. When there are no more processes to iterate then
+// syscall.ERROR_NO_MORE_FILES is returned (use errors.Cause() to unwrap).
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms684836
+func Process32Next(handle syscall.Handle) (ProcessEntry32, error) {
+	processEntry32 := ProcessEntry32{size: sizeofProcessEntry32}
+	err := _Process32Next(handle, &processEntry32)
+	if err != nil {
+		return ProcessEntry32{}, errors.Wrap(err, "Process32Next failed")
+	}
+
+	return processEntry32, nil
+}
+
+// Use "GOOS=windows go generate -v -x ." to generate the source.
+
+// Add -trace to enable debug prints around syscalls.
+//go:generate go run $GOROOT/src/syscall/mksyscall_windows.go -output zsyscall_windows.go syscall_windows.go
+
+// Windows API calls
+//sys   _GlobalMemoryStatusEx(buffer *MemoryStatusEx) (err error) = kernel32.GlobalMemoryStatusEx
+//sys   _GetLogicalDriveStringsW(bufferLength uint32, buffer *uint16) (length uint32, err error) = kernel32.GetLogicalDriveStringsW
+//sys   _GetProcessMemoryInfo(handle syscall.Handle, psmemCounters *ProcessMemoryCountersEx, cb uint32) (err error) = psapi.GetProcessMemoryInfo
+//sys   _GetProcessImageFileName(handle syscall.Handle, outImageFileName *uint16, size uint32) (length uint32, err error) = psapi.GetProcessImageFileNameW
+//sys   _GetSystemTimes(idleTime *syscall.Filetime, kernelTime *syscall.Filetime, userTime *syscall.Filetime) (err error) = kernel32.GetSystemTimes
+//sys   _GetDriveType(rootPathName *uint16) (dt DriveType, err error) = kernel32.GetDriveTypeW
+//sys   _EnumProcesses(processIds *uint32, sizeBytes uint32, bytesReturned *uint32) (err error) = psapi.EnumProcesses
+//sys   _GetDiskFreeSpaceEx(directoryName *uint16, freeBytesAvailable *uint64, totalNumberOfBytes *uint64, totalNumberOfFreeBytes *uint64) (err error) = kernel32.GetDiskFreeSpaceExW
+//sys   _Process32First(handle syscall.Handle, processEntry32 *ProcessEntry32) (err error) = kernel32.Process32FirstW
+//sys   _Process32Next(handle syscall.Handle, processEntry32 *ProcessEntry32) (err error) = kernel32.Process32NextW
+//sys   _CreateToolhelp32Snapshot(flags uint32, processID uint32) (handle syscall.Handle, err error) = kernel32.CreateToolhelp32Snapshot
+//sys   _NtQuerySystemInformation(systemInformationClass uint32, systemInformation *byte, systemInformationLength uint32, returnLength *uint32) (ntstatus uint32, err error) = ntdll.NtQuerySystemInformation
+//sys   _NtQueryInformationProcess(processHandle syscall.Handle, processInformationClass uint32, processInformation *byte, processInformationLength uint32, returnLength *uint32) (ntstatus uint32, err error) = ntdll.NtQueryInformationProcess
+//sys   _LookupPrivilegeName(systemName string, luid *int64, buffer *uint16, size *uint32) (err error) = advapi32.LookupPrivilegeNameW
+//sys   _LookupPrivilegeValue(systemName string, name string, luid *int64) (err error) = advapi32.LookupPrivilegeValueW
+//sys   _AdjustTokenPrivileges(token syscall.Token, releaseAll bool, input *byte, outputSize uint32, output *byte, requiredSize *uint32) (success bool, err error) [true] = advapi32.AdjustTokenPrivileges

vendor/github.com/elastic/gosigar/sys/windows/version.go

@@ -0,0 +1,43 @@
+// +build windows
+
+package windows
+
+import (
+	"fmt"
+	"syscall"
+)
+
+// Version identifies a Windows version by major, minor, and build number.
+type Version struct {
+	Major int
+	Minor int
+	Build int
+}
+
+// GetWindowsVersion returns the Windows version information. Applications not
+// manifested for Windows 8.1 or Windows 10 will return the Windows 8 OS version
+// value (6.2).
+//
+// For a table of version numbers see:
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms724833(v=vs.85).aspx
+func GetWindowsVersion() Version {
+	// https://msdn.microsoft.com/en-us/library/windows/desktop/ms724439(v=vs.85).aspx
+	ver, err := syscall.GetVersion()
+	if err != nil {
+		// GetVersion should never return an error.
+		panic(fmt.Errorf("GetVersion failed: %v", err))
+	}
+
+	return Version{
+		Major: int(ver & 0xFF),
+		Minor: int(ver >> 8 & 0xFF),
+		Build: int(ver >> 16),
+	}
+}
+
+// IsWindowsVistaOrGreater returns true if the Windows version is Vista or
+// greater.
+func (v Version) IsWindowsVistaOrGreater() bool {
+	// Vista is 6.0.
+	return v.Major >= 6 && v.Minor >= 0
+}

vendor/github.com/elastic/gosigar/sys/windows/zsyscall_windows.go

@@ -0,0 +1,260 @@
+// MACHINE GENERATED BY 'go generate' COMMAND; DO NOT EDIT
+
+package windows
+
+import "unsafe"
+import "syscall"
+
+var _ unsafe.Pointer
+
+var (
+	modkernel32 = syscall.NewLazyDLL("kernel32.dll")
+	modpsapi    = syscall.NewLazyDLL("psapi.dll")
+	modntdll    = syscall.NewLazyDLL("ntdll.dll")
+	modadvapi32 = syscall.NewLazyDLL("advapi32.dll")
+
+	procGlobalMemoryStatusEx      = modkernel32.NewProc("GlobalMemoryStatusEx")
+	procGetLogicalDriveStringsW   = modkernel32.NewProc("GetLogicalDriveStringsW")
+	procGetProcessMemoryInfo      = modpsapi.NewProc("GetProcessMemoryInfo")
+	procGetProcessImageFileNameW  = modpsapi.NewProc("GetProcessImageFileNameW")
+	procGetSystemTimes            = modkernel32.NewProc("GetSystemTimes")
+	procGetDriveTypeW             = modkernel32.NewProc("GetDriveTypeW")
+	procEnumProcesses             = modpsapi.NewProc("EnumProcesses")
+	procGetDiskFreeSpaceExW       = modkernel32.NewProc("GetDiskFreeSpaceExW")
+	procProcess32FirstW           = modkernel32.NewProc("Process32FirstW")
+	procProcess32NextW            = modkernel32.NewProc("Process32NextW")
+	procCreateToolhelp32Snapshot  = modkernel32.NewProc("CreateToolhelp32Snapshot")
+	procNtQuerySystemInformation  = modntdll.NewProc("NtQuerySystemInformation")
+	procNtQueryInformationProcess = modntdll.NewProc("NtQueryInformationProcess")
+	procLookupPrivilegeNameW      = modadvapi32.NewProc("LookupPrivilegeNameW")
+	procLookupPrivilegeValueW     = modadvapi32.NewProc("LookupPrivilegeValueW")
+	procAdjustTokenPrivileges     = modadvapi32.NewProc("AdjustTokenPrivileges")
+)
+
+func _GlobalMemoryStatusEx(buffer *MemoryStatusEx) (err error) {
+	r1, _, e1 := syscall.Syscall(procGlobalMemoryStatusEx.Addr(), 1, uintptr(unsafe.Pointer(buffer)), 0, 0)
+	if r1 == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _GetLogicalDriveStringsW(bufferLength uint32, buffer *uint16) (length uint32, err error) {
+	r0, _, e1 := syscall.Syscall(procGetLogicalDriveStringsW.Addr(), 2, uintptr(bufferLength), uintptr(unsafe.Pointer(buffer)), 0)
+	length = uint32(r0)
+	if length == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _GetProcessMemoryInfo(handle syscall.Handle, psmemCounters *ProcessMemoryCountersEx, cb uint32) (err error) {
+	r1, _, e1 := syscall.Syscall(procGetProcessMemoryInfo.Addr(), 3, uintptr(handle), uintptr(unsafe.Pointer(psmemCounters)), uintptr(cb))
+	if r1 == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _GetProcessImageFileName(handle syscall.Handle, outImageFileName *uint16, size uint32) (length uint32, err error) {
+	r0, _, e1 := syscall.Syscall(procGetProcessImageFileNameW.Addr(), 3, uintptr(handle), uintptr(unsafe.Pointer(outImageFileName)), uintptr(size))
+	length = uint32(r0)
+	if length == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _GetSystemTimes(idleTime *syscall.Filetime, kernelTime *syscall.Filetime, userTime *syscall.Filetime) (err error) {
+	r1, _, e1 := syscall.Syscall(procGetSystemTimes.Addr(), 3, uintptr(unsafe.Pointer(idleTime)), uintptr(unsafe.Pointer(kernelTime)), uintptr(unsafe.Pointer(userTime)))
+	if r1 == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _GetDriveType(rootPathName *uint16) (dt DriveType, err error) {
+	r0, _, e1 := syscall.Syscall(procGetDriveTypeW.Addr(), 1, uintptr(unsafe.Pointer(rootPathName)), 0, 0)
+	dt = DriveType(r0)
+	if dt == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _EnumProcesses(processIds *uint32, sizeBytes uint32, bytesReturned *uint32) (err error) {
+	r1, _, e1 := syscall.Syscall(procEnumProcesses.Addr(), 3, uintptr(unsafe.Pointer(processIds)), uintptr(sizeBytes), uintptr(unsafe.Pointer(bytesReturned)))
+	if r1 == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _GetDiskFreeSpaceEx(directoryName *uint16, freeBytesAvailable *uint64, totalNumberOfBytes *uint64, totalNumberOfFreeBytes *uint64) (err error) {
+	r1, _, e1 := syscall.Syscall6(procGetDiskFreeSpaceExW.Addr(), 4, uintptr(unsafe.Pointer(directoryName)), uintptr(unsafe.Pointer(freeBytesAvailable)), uintptr(unsafe.Pointer(totalNumberOfBytes)), uintptr(unsafe.Pointer(totalNumberOfFreeBytes)), 0, 0)
+	if r1 == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _Process32First(handle syscall.Handle, processEntry32 *ProcessEntry32) (err error) {
+	r1, _, e1 := syscall.Syscall(procProcess32FirstW.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(processEntry32)), 0)
+	if r1 == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _Process32Next(handle syscall.Handle, processEntry32 *ProcessEntry32) (err error) {
+	r1, _, e1 := syscall.Syscall(procProcess32NextW.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(processEntry32)), 0)
+	if r1 == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _CreateToolhelp32Snapshot(flags uint32, processID uint32) (handle syscall.Handle, err error) {
+	r0, _, e1 := syscall.Syscall(procCreateToolhelp32Snapshot.Addr(), 2, uintptr(flags), uintptr(processID), 0)
+	handle = syscall.Handle(r0)
+	if handle == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _NtQuerySystemInformation(systemInformationClass uint32, systemInformation *byte, systemInformationLength uint32, returnLength *uint32) (ntstatus uint32, err error) {
+	r0, _, e1 := syscall.Syscall6(procNtQuerySystemInformation.Addr(), 4, uintptr(systemInformationClass), uintptr(unsafe.Pointer(systemInformation)), uintptr(systemInformationLength), uintptr(unsafe.Pointer(returnLength)), 0, 0)
+	ntstatus = uint32(r0)
+	if ntstatus == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _NtQueryInformationProcess(processHandle syscall.Handle, processInformationClass uint32, processInformation *byte, processInformationLength uint32, returnLength *uint32) (ntstatus uint32, err error) {
+	r0, _, e1 := syscall.Syscall6(procNtQueryInformationProcess.Addr(), 5, uintptr(processHandle), uintptr(processInformationClass), uintptr(unsafe.Pointer(processInformation)), uintptr(processInformationLength), uintptr(unsafe.Pointer(returnLength)), 0)
+	ntstatus = uint32(r0)
+	if ntstatus == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _LookupPrivilegeName(systemName string, luid *int64, buffer *uint16, size *uint32) (err error) {
+	var _p0 *uint16
+	_p0, err = syscall.UTF16PtrFromString(systemName)
+	if err != nil {
+		return
+	}
+	return __LookupPrivilegeName(_p0, luid, buffer, size)
+}
+
+func __LookupPrivilegeName(systemName *uint16, luid *int64, buffer *uint16, size *uint32) (err error) {
+	r1, _, e1 := syscall.Syscall6(procLookupPrivilegeNameW.Addr(), 4, uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(luid)), uintptr(unsafe.Pointer(buffer)), uintptr(unsafe.Pointer(size)), 0, 0)
+	if r1 == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _LookupPrivilegeValue(systemName string, name string, luid *int64) (err error) {
+	var _p0 *uint16
+	_p0, err = syscall.UTF16PtrFromString(systemName)
+	if err != nil {
+		return
+	}
+	var _p1 *uint16
+	_p1, err = syscall.UTF16PtrFromString(name)
+	if err != nil {
+		return
+	}
+	return __LookupPrivilegeValue(_p0, _p1, luid)
+}
+
+func __LookupPrivilegeValue(systemName *uint16, name *uint16, luid *int64) (err error) {
+	r1, _, e1 := syscall.Syscall(procLookupPrivilegeValueW.Addr(), 3, uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(luid)))
+	if r1 == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _AdjustTokenPrivileges(token syscall.Token, releaseAll bool, input *byte, outputSize uint32, output *byte, requiredSize *uint32) (success bool, err error) {
+	var _p0 uint32
+	if releaseAll {
+		_p0 = 1
+	} else {
+		_p0 = 0
+	}
+	r0, _, e1 := syscall.Syscall6(procAdjustTokenPrivileges.Addr(), 6, uintptr(token), uintptr(_p0), uintptr(unsafe.Pointer(input)), uintptr(outputSize), uintptr(unsafe.Pointer(output)), uintptr(unsafe.Pointer(requiredSize)))
+	success = r0 != 0
+	if true {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}

vendor/github.com/go-ole/go-ole/ChangeLog.md

@@ -0,0 +1,49 @@
+# Version 1.x.x
+
+* **Add more test cases and reference new test COM server project.** (Placeholder for future additions)
+
+# Version 1.2.0-alphaX
+
+**Minimum supported version is now Go 1.4. Go 1.1 support is deprecated, but should still build.**
+
+ * Added CI configuration for Travis-CI and AppVeyor.
+ * Added test InterfaceID and ClassID for the COM Test Server project.
+ * Added more inline documentation (#83).
+ * Added IEnumVARIANT implementation (#88).
+ * Added IEnumVARIANT test cases (#99, #100, #101).
+ * Added support for retrieving `time.Time` from VARIANT (#92).
+ * Added test case for IUnknown (#64).
+ * Added test case for IDispatch (#64).
+ * Added test cases for scalar variants (#64, #76).
+
+# Version 1.1.1
+
+ * Fixes for Linux build.
+ * Fixes for Windows build.
+
+# Version 1.1.0
+
+The change to provide building on all platforms is a new feature. The increase in minor version reflects that and allows those who wish to stay on 1.0.x to continue to do so. Support for 1.0.x will be limited to bug fixes.
+
+ * Move GUID out of variables.go into its own file to make new documentation available.
+ * Move OleError out of ole.go into its own file to make new documentation available.
+ * Add documentation to utility functions.
+ * Add documentation to variant receiver functions.
+ * Add documentation to ole structures.
+ * Make variant available to other systems outside of Windows.
+ * Make OLE structures available to other systems outside of Windows.
+
+## New Features
+
+ * Library should now be built on all platforms supported by Go. Library will NOOP on any platform that is not Windows.
+ * More functions are now documented and available on godoc.org.
+
+# Version 1.0.1
+
+ 1. Fix package references from repository location change.
+
+# Version 1.0.0
+
+This version is stable enough for use. The COM API is still incomplete, but provides enough functionality for accessing COM servers using IDispatch interface.
+
+There is no changelog for this version. Check commits for history.

vendor/github.com/go-ole/go-ole/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright © 2013-2017 Yasuhiro Matsumoto, <mattn.jp@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the “Software”), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/go-ole/go-ole/README.md

@@ -0,0 +1,46 @@
+#Go OLE
+
+[![Build status](https://ci.appveyor.com/api/projects/status/qr0u2sf7q43us9fj?svg=true)](https://ci.appveyor.com/project/jacobsantos/go-ole-jgs28)
+[![Build Status](https://travis-ci.org/go-ole/go-ole.svg?branch=master)](https://travis-ci.org/go-ole/go-ole)
+[![GoDoc](https://godoc.org/github.com/go-ole/go-ole?status.svg)](https://godoc.org/github.com/go-ole/go-ole)
+
+Go bindings for Windows COM using shared libraries instead of cgo.
+
+By Yasuhiro Matsumoto.
+
+## Install
+
+To experiment with go-ole, you can just compile and run the example program:
+
+```
+go get github.com/go-ole/go-ole
+cd /path/to/go-ole/
+go test
+
+cd /path/to/go-ole/example/excel
+go run excel.go
+```
+
+## Continuous Integration
+
+Continuous integration configuration has been added for both Travis-CI and AppVeyor. You will have to add these to your own account for your fork in order for it to run.
+
+**Travis-CI**
+
+Travis-CI was added to check builds on Linux to ensure that `go get` works when cross building. Currently, Travis-CI is not used to test cross-building, but this may be changed in the future. It is also not currently possible to test the library on Linux, since COM API is specific to Windows and it is not currently possible to run a COM server on Linux or even connect to a remote COM server.
+
+**AppVeyor**
+
+AppVeyor is used to build on Windows using the (in-development) test COM server. It is currently only used to test the build and ensure that the code works on Windows. It will be used to register a COM server and then run the test cases based on the test COM server.
+
+The tests currently do run and do pass and this should be maintained with commits.
+
+##Versioning
+
+Go OLE uses [semantic versioning](http://semver.org) for version numbers, which is similar to the version contract of the Go language. Which means that the major version will always maintain backwards compatibility with minor versions. Minor versions will only add new additions and changes. Fixes will always be in patch. 
+
+This contract should allow you to upgrade to new minor and patch versions without breakage or modifications to your existing code. Leave a ticket, if there is breakage, so that it could be fixed.
+
+##LICENSE
+
+Under the MIT License: http://mattn.mit-license.org/2013

vendor/github.com/go-ole/go-ole/appveyor.yml

@@ -0,0 +1,54 @@
+# Notes:
+#   - Minimal appveyor.yml file is an empty file. All sections are optional.
+#   - Indent each level of configuration with 2 spaces. Do not use tabs!
+#   - All section names are case-sensitive.
+#   - Section names should be unique on each level.
+
+version: "1.3.0.{build}-alpha-{branch}"
+
+os: Windows Server 2012 R2
+
+branches:
+  only:
+    - master
+    - v1.2
+    - v1.1
+    - v1.0
+
+skip_tags: true
+
+clone_folder: c:\gopath\src\github.com\go-ole\go-ole
+
+environment:
+  GOPATH: c:\gopath
+  matrix:
+  - GOARCH: amd64
+    GOVERSION: 1.5
+    GOROOT: c:\go
+    DOWNLOADPLATFORM: "x64"
+
+install:
+  - choco install mingw
+  - SET PATH=c:\tools\mingw64\bin;%PATH%
+  # - Download COM Server
+  - ps: Start-FileDownload "https://github.com/go-ole/test-com-server/releases/download/v1.0.2/test-com-server-${env:DOWNLOADPLATFORM}.zip"
+  - 7z e test-com-server-%DOWNLOADPLATFORM%.zip -oc:\gopath\src\github.com\go-ole\go-ole > NUL
+  - c:\gopath\src\github.com\go-ole\go-ole\build\register-assembly.bat
+  # - set
+  - go version
+  - go env
+  - go get -u golang.org/x/tools/cmd/cover
+  - go get -u golang.org/x/tools/cmd/godoc
+  - go get -u golang.org/x/tools/cmd/stringer
+
+build_script:
+  - cd c:\gopath\src\github.com\go-ole\go-ole
+  - go get -v -t ./...
+  - go build
+  - go test -v -cover ./...
+
+# disable automatic tests
+test: off
+
+# disable deployment
+deploy: off

vendor/github.com/go-ole/go-ole/com.go

@@ -0,0 +1,329 @@
+// +build windows
+
+package ole
+
+import (
+	"errors"
+	"syscall"
+	"time"
+	"unicode/utf16"
+	"unsafe"
+)
+
+var (
+	procCoInitialize, _            = modole32.FindProc("CoInitialize")
+	procCoInitializeEx, _          = modole32.FindProc("CoInitializeEx")
+	procCoUninitialize, _          = modole32.FindProc("CoUninitialize")
+	procCoCreateInstance, _        = modole32.FindProc("CoCreateInstance")
+	procCoTaskMemFree, _           = modole32.FindProc("CoTaskMemFree")
+	procCLSIDFromProgID, _         = modole32.FindProc("CLSIDFromProgID")
+	procCLSIDFromString, _         = modole32.FindProc("CLSIDFromString")
+	procStringFromCLSID, _         = modole32.FindProc("StringFromCLSID")
+	procStringFromIID, _           = modole32.FindProc("StringFromIID")
+	procIIDFromString, _           = modole32.FindProc("IIDFromString")
+	procGetUserDefaultLCID, _      = modkernel32.FindProc("GetUserDefaultLCID")
+	procCopyMemory, _              = modkernel32.FindProc("RtlMoveMemory")
+	procVariantInit, _             = modoleaut32.FindProc("VariantInit")
+	procVariantClear, _            = modoleaut32.FindProc("VariantClear")
+	procVariantTimeToSystemTime, _ = modoleaut32.FindProc("VariantTimeToSystemTime")
+	procSysAllocString, _          = modoleaut32.FindProc("SysAllocString")
+	procSysAllocStringLen, _       = modoleaut32.FindProc("SysAllocStringLen")
+	procSysFreeString, _           = modoleaut32.FindProc("SysFreeString")
+	procSysStringLen, _            = modoleaut32.FindProc("SysStringLen")
+	procCreateDispTypeInfo, _      = modoleaut32.FindProc("CreateDispTypeInfo")
+	procCreateStdDispatch, _       = modoleaut32.FindProc("CreateStdDispatch")
+	procGetActiveObject, _         = modoleaut32.FindProc("GetActiveObject")
+
+	procGetMessageW, _      = moduser32.FindProc("GetMessageW")
+	procDispatchMessageW, _ = moduser32.FindProc("DispatchMessageW")
+)
+
+// coInitialize initializes COM library on current thread.
+//
+// MSDN documentation suggests that this function should not be called. Call
+// CoInitializeEx() instead. The reason has to do with threading and this
+// function is only for single-threaded apartments.
+//
+// That said, most users of the library have gotten away with just this
+// function. If you are experiencing threading issues, then use
+// CoInitializeEx().
+func coInitialize() (err error) {
+	// http://msdn.microsoft.com/en-us/library/windows/desktop/ms678543(v=vs.85).aspx
+	// Suggests that no value should be passed to CoInitialized.
+	// Could just be Call() since the parameter is optional. <-- Needs testing to be sure.
+	hr, _, _ := procCoInitialize.Call(uintptr(0))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// coInitializeEx initializes COM library with concurrency model.
+func coInitializeEx(coinit uint32) (err error) {
+	// http://msdn.microsoft.com/en-us/library/windows/desktop/ms695279(v=vs.85).aspx
+	// Suggests that the first parameter is not only optional but should always be NULL.
+	hr, _, _ := procCoInitializeEx.Call(uintptr(0), uintptr(coinit))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// CoInitialize initializes COM library on current thread.
+//
+// MSDN documentation suggests that this function should not be called. Call
+// CoInitializeEx() instead. The reason has to do with threading and this
+// function is only for single-threaded apartments.
+//
+// That said, most users of the library have gotten away with just this
+// function. If you are experiencing threading issues, then use
+// CoInitializeEx().
+func CoInitialize(p uintptr) (err error) {
+	// p is ignored and won't be used.
+	// Avoid any variable not used errors.
+	p = uintptr(0)
+	return coInitialize()
+}
+
+// CoInitializeEx initializes COM library with concurrency model.
+func CoInitializeEx(p uintptr, coinit uint32) (err error) {
+	// Avoid any variable not used errors.
+	p = uintptr(0)
+	return coInitializeEx(coinit)
+}
+
+// CoUninitialize uninitializes COM Library.
+func CoUninitialize() {
+	procCoUninitialize.Call()
+}
+
+// CoTaskMemFree frees memory pointer.
+func CoTaskMemFree(memptr uintptr) {
+	procCoTaskMemFree.Call(memptr)
+}
+
+// CLSIDFromProgID retrieves Class Identifier with the given Program Identifier.
+//
+// The Programmatic Identifier must be registered, because it will be looked up
+// in the Windows Registry. The registry entry has the following keys: CLSID,
+// Insertable, Protocol and Shell
+// (https://msdn.microsoft.com/en-us/library/dd542719(v=vs.85).aspx).
+//
+// programID identifies the class id with less precision and is not guaranteed
+// to be unique. These are usually found in the registry under
+// HKEY_LOCAL_MACHINE\SOFTWARE\Classes, usually with the format of
+// "Program.Component.Version" with version being optional.
+//
+// CLSIDFromProgID in Windows API.
+func CLSIDFromProgID(progId string) (clsid *GUID, err error) {
+	var guid GUID
+	lpszProgID := uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(progId)))
+	hr, _, _ := procCLSIDFromProgID.Call(lpszProgID, uintptr(unsafe.Pointer(&guid)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	clsid = &guid
+	return
+}
+
+// CLSIDFromString retrieves Class ID from string representation.
+//
+// This is technically the string version of the GUID and will convert the
+// string to object.
+//
+// CLSIDFromString in Windows API.
+func CLSIDFromString(str string) (clsid *GUID, err error) {
+	var guid GUID
+	lpsz := uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(str)))
+	hr, _, _ := procCLSIDFromString.Call(lpsz, uintptr(unsafe.Pointer(&guid)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	clsid = &guid
+	return
+}
+
+// StringFromCLSID returns GUID formated string from GUID object.
+func StringFromCLSID(clsid *GUID) (str string, err error) {
+	var p *uint16
+	hr, _, _ := procStringFromCLSID.Call(uintptr(unsafe.Pointer(clsid)), uintptr(unsafe.Pointer(&p)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	str = LpOleStrToString(p)
+	return
+}
+
+// IIDFromString returns GUID from program ID.
+func IIDFromString(progId string) (clsid *GUID, err error) {
+	var guid GUID
+	lpsz := uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(progId)))
+	hr, _, _ := procIIDFromString.Call(lpsz, uintptr(unsafe.Pointer(&guid)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	clsid = &guid
+	return
+}
+
+// StringFromIID returns GUID formatted string from GUID object.
+func StringFromIID(iid *GUID) (str string, err error) {
+	var p *uint16
+	hr, _, _ := procStringFromIID.Call(uintptr(unsafe.Pointer(iid)), uintptr(unsafe.Pointer(&p)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	str = LpOleStrToString(p)
+	return
+}
+
+// CreateInstance of single uninitialized object with GUID.
+func CreateInstance(clsid *GUID, iid *GUID) (unk *IUnknown, err error) {
+	if iid == nil {
+		iid = IID_IUnknown
+	}
+	hr, _, _ := procCoCreateInstance.Call(
+		uintptr(unsafe.Pointer(clsid)),
+		0,
+		CLSCTX_SERVER,
+		uintptr(unsafe.Pointer(iid)),
+		uintptr(unsafe.Pointer(&unk)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// GetActiveObject retrieves pointer to active object.
+func GetActiveObject(clsid *GUID, iid *GUID) (unk *IUnknown, err error) {
+	if iid == nil {
+		iid = IID_IUnknown
+	}
+	hr, _, _ := procGetActiveObject.Call(
+		uintptr(unsafe.Pointer(clsid)),
+		uintptr(unsafe.Pointer(iid)),
+		uintptr(unsafe.Pointer(&unk)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// VariantInit initializes variant.
+func VariantInit(v *VARIANT) (err error) {
+	hr, _, _ := procVariantInit.Call(uintptr(unsafe.Pointer(v)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// VariantClear clears value in Variant settings to VT_EMPTY.
+func VariantClear(v *VARIANT) (err error) {
+	hr, _, _ := procVariantClear.Call(uintptr(unsafe.Pointer(v)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// SysAllocString allocates memory for string and copies string into memory.
+func SysAllocString(v string) (ss *int16) {
+	pss, _, _ := procSysAllocString.Call(uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(v))))
+	ss = (*int16)(unsafe.Pointer(pss))
+	return
+}
+
+// SysAllocStringLen copies up to length of given string returning pointer.
+func SysAllocStringLen(v string) (ss *int16) {
+	utf16 := utf16.Encode([]rune(v + "\x00"))
+	ptr := &utf16[0]
+
+	pss, _, _ := procSysAllocStringLen.Call(uintptr(unsafe.Pointer(ptr)), uintptr(len(utf16)-1))
+	ss = (*int16)(unsafe.Pointer(pss))
+	return
+}
+
+// SysFreeString frees string system memory. This must be called with SysAllocString.
+func SysFreeString(v *int16) (err error) {
+	hr, _, _ := procSysFreeString.Call(uintptr(unsafe.Pointer(v)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// SysStringLen is the length of the system allocated string.
+func SysStringLen(v *int16) uint32 {
+	l, _, _ := procSysStringLen.Call(uintptr(unsafe.Pointer(v)))
+	return uint32(l)
+}
+
+// CreateStdDispatch provides default IDispatch implementation for IUnknown.
+//
+// This handles default IDispatch implementation for objects. It haves a few
+// limitations with only supporting one language. It will also only return
+// default exception codes.
+func CreateStdDispatch(unk *IUnknown, v uintptr, ptinfo *IUnknown) (disp *IDispatch, err error) {
+	hr, _, _ := procCreateStdDispatch.Call(
+		uintptr(unsafe.Pointer(unk)),
+		v,
+		uintptr(unsafe.Pointer(ptinfo)),
+		uintptr(unsafe.Pointer(&disp)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// CreateDispTypeInfo provides default ITypeInfo implementation for IDispatch.
+//
+// This will not handle the full implementation of the interface.
+func CreateDispTypeInfo(idata *INTERFACEDATA) (pptinfo *IUnknown, err error) {
+	hr, _, _ := procCreateDispTypeInfo.Call(
+		uintptr(unsafe.Pointer(idata)),
+		uintptr(GetUserDefaultLCID()),
+		uintptr(unsafe.Pointer(&pptinfo)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// copyMemory moves location of a block of memory.
+func copyMemory(dest unsafe.Pointer, src unsafe.Pointer, length uint32) {
+	procCopyMemory.Call(uintptr(dest), uintptr(src), uintptr(length))
+}
+
+// GetUserDefaultLCID retrieves current user default locale.
+func GetUserDefaultLCID() (lcid uint32) {
+	ret, _, _ := procGetUserDefaultLCID.Call()
+	lcid = uint32(ret)
+	return
+}
+
+// GetMessage in message queue from runtime.
+//
+// This function appears to block. PeekMessage does not block.
+func GetMessage(msg *Msg, hwnd uint32, MsgFilterMin uint32, MsgFilterMax uint32) (ret int32, err error) {
+	r0, _, err := procGetMessageW.Call(uintptr(unsafe.Pointer(msg)), uintptr(hwnd), uintptr(MsgFilterMin), uintptr(MsgFilterMax))
+	ret = int32(r0)
+	return
+}
+
+// DispatchMessage to window procedure.
+func DispatchMessage(msg *Msg) (ret int32) {
+	r0, _, _ := procDispatchMessageW.Call(uintptr(unsafe.Pointer(msg)))
+	ret = int32(r0)
+	return
+}
+
+// GetVariantDate converts COM Variant Time value to Go time.Time.
+func GetVariantDate(value float64) (time.Time, error) {
+	var st syscall.Systemtime
+	r, _, _ := procVariantTimeToSystemTime.Call(uintptr(value), uintptr(unsafe.Pointer(&st)))
+	if r != 0 {
+		return time.Date(int(st.Year), time.Month(st.Month), int(st.Day), int(st.Hour), int(st.Minute), int(st.Second), int(st.Milliseconds/1000), time.UTC), nil
+	}
+	return time.Now(), errors.New("Could not convert to time, passing current time.")
+}

vendor/github.com/go-ole/go-ole/com_func.go

@@ -0,0 +1,174 @@
+// +build !windows
+
+package ole
+
+import (
+	"time"
+	"unsafe"
+)
+
+// coInitialize initializes COM library on current thread.
+//
+// MSDN documentation suggests that this function should not be called. Call
+// CoInitializeEx() instead. The reason has to do with threading and this
+// function is only for single-threaded apartments.
+//
+// That said, most users of the library have gotten away with just this
+// function. If you are experiencing threading issues, then use
+// CoInitializeEx().
+func coInitialize() error {
+	return NewError(E_NOTIMPL)
+}
+
+// coInitializeEx initializes COM library with concurrency model.
+func coInitializeEx(coinit uint32) error {
+	return NewError(E_NOTIMPL)
+}
+
+// CoInitialize initializes COM library on current thread.
+//
+// MSDN documentation suggests that this function should not be called. Call
+// CoInitializeEx() instead. The reason has to do with threading and this
+// function is only for single-threaded apartments.
+//
+// That said, most users of the library have gotten away with just this
+// function. If you are experiencing threading issues, then use
+// CoInitializeEx().
+func CoInitialize(p uintptr) error {
+	return NewError(E_NOTIMPL)
+}
+
+// CoInitializeEx initializes COM library with concurrency model.
+func CoInitializeEx(p uintptr, coinit uint32) error {
+	return NewError(E_NOTIMPL)
+}
+
+// CoUninitialize uninitializes COM Library.
+func CoUninitialize() {}
+
+// CoTaskMemFree frees memory pointer.
+func CoTaskMemFree(memptr uintptr) {}
+
+// CLSIDFromProgID retrieves Class Identifier with the given Program Identifier.
+//
+// The Programmatic Identifier must be registered, because it will be looked up
+// in the Windows Registry. The registry entry has the following keys: CLSID,
+// Insertable, Protocol and Shell
+// (https://msdn.microsoft.com/en-us/library/dd542719(v=vs.85).aspx).
+//
+// programID identifies the class id with less precision and is not guaranteed
+// to be unique. These are usually found in the registry under
+// HKEY_LOCAL_MACHINE\SOFTWARE\Classes, usually with the format of
+// "Program.Component.Version" with version being optional.
+//
+// CLSIDFromProgID in Windows API.
+func CLSIDFromProgID(progId string) (*GUID, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// CLSIDFromString retrieves Class ID from string representation.
+//
+// This is technically the string version of the GUID and will convert the
+// string to object.
+//
+// CLSIDFromString in Windows API.
+func CLSIDFromString(str string) (*GUID, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// StringFromCLSID returns GUID formated string from GUID object.
+func StringFromCLSID(clsid *GUID) (string, error) {
+	return "", NewError(E_NOTIMPL)
+}
+
+// IIDFromString returns GUID from program ID.
+func IIDFromString(progId string) (*GUID, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// StringFromIID returns GUID formatted string from GUID object.
+func StringFromIID(iid *GUID) (string, error) {
+	return "", NewError(E_NOTIMPL)
+}
+
+// CreateInstance of single uninitialized object with GUID.
+func CreateInstance(clsid *GUID, iid *GUID) (*IUnknown, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// GetActiveObject retrieves pointer to active object.
+func GetActiveObject(clsid *GUID, iid *GUID) (*IUnknown, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// VariantInit initializes variant.
+func VariantInit(v *VARIANT) error {
+	return NewError(E_NOTIMPL)
+}
+
+// VariantClear clears value in Variant settings to VT_EMPTY.
+func VariantClear(v *VARIANT) error {
+	return NewError(E_NOTIMPL)
+}
+
+// SysAllocString allocates memory for string and copies string into memory.
+func SysAllocString(v string) *int16 {
+	u := int16(0)
+	return &u
+}
+
+// SysAllocStringLen copies up to length of given string returning pointer.
+func SysAllocStringLen(v string) *int16 {
+	u := int16(0)
+	return &u
+}
+
+// SysFreeString frees string system memory. This must be called with SysAllocString.
+func SysFreeString(v *int16) error {
+	return NewError(E_NOTIMPL)
+}
+
+// SysStringLen is the length of the system allocated string.
+func SysStringLen(v *int16) uint32 {
+	return uint32(0)
+}
+
+// CreateStdDispatch provides default IDispatch implementation for IUnknown.
+//
+// This handles default IDispatch implementation for objects. It haves a few
+// limitations with only supporting one language. It will also only return
+// default exception codes.
+func CreateStdDispatch(unk *IUnknown, v uintptr, ptinfo *IUnknown) (*IDispatch, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// CreateDispTypeInfo provides default ITypeInfo implementation for IDispatch.
+//
+// This will not handle the full implementation of the interface.
+func CreateDispTypeInfo(idata *INTERFACEDATA) (*IUnknown, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// copyMemory moves location of a block of memory.
+func copyMemory(dest unsafe.Pointer, src unsafe.Pointer, length uint32) {}
+
+// GetUserDefaultLCID retrieves current user default locale.
+func GetUserDefaultLCID() uint32 {
+	return uint32(0)
+}
+
+// GetMessage in message queue from runtime.
+//
+// This function appears to block. PeekMessage does not block.
+func GetMessage(msg *Msg, hwnd uint32, MsgFilterMin uint32, MsgFilterMax uint32) (int32, error) {
+	return int32(0), NewError(E_NOTIMPL)
+}
+
+// DispatchMessage to window procedure.
+func DispatchMessage(msg *Msg) int32 {
+	return int32(0)
+}
+
+func GetVariantDate(value float64) (time.Time, error) {
+	return time.Now(), NewError(E_NOTIMPL)
+}

vendor/github.com/go-ole/go-ole/connect.go

@@ -0,0 +1,192 @@
+package ole
+
+// Connection contains IUnknown for fluent interface interaction.
+//
+// Deprecated. Use oleutil package instead.
+type Connection struct {
+	Object *IUnknown // Access COM
+}
+
+// Initialize COM.
+func (*Connection) Initialize() (err error) {
+	return coInitialize()
+}
+
+// Uninitialize COM.
+func (*Connection) Uninitialize() {
+	CoUninitialize()
+}
+
+// Create IUnknown object based first on ProgId and then from String.
+func (c *Connection) Create(progId string) (err error) {
+	var clsid *GUID
+	clsid, err = CLSIDFromProgID(progId)
+	if err != nil {
+		clsid, err = CLSIDFromString(progId)
+		if err != nil {
+			return
+		}
+	}
+
+	unknown, err := CreateInstance(clsid, IID_IUnknown)
+	if err != nil {
+		return
+	}
+	c.Object = unknown
+
+	return
+}
+
+// Release IUnknown object.
+func (c *Connection) Release() {
+	c.Object.Release()
+}
+
+// Load COM object from list of programIDs or strings.
+func (c *Connection) Load(names ...string) (errors []error) {
+	var tempErrors []error = make([]error, len(names))
+	var numErrors int = 0
+	for _, name := range names {
+		err := c.Create(name)
+		if err != nil {
+			tempErrors = append(tempErrors, err)
+			numErrors += 1
+			continue
+		}
+		break
+	}
+
+	copy(errors, tempErrors[0:numErrors])
+	return
+}
+
+// Dispatch returns Dispatch object.
+func (c *Connection) Dispatch() (object *Dispatch, err error) {
+	dispatch, err := c.Object.QueryInterface(IID_IDispatch)
+	if err != nil {
+		return
+	}
+	object = &Dispatch{dispatch}
+	return
+}
+
+// Dispatch stores IDispatch object.
+type Dispatch struct {
+	Object *IDispatch // Dispatch object.
+}
+
+// Call method on IDispatch with parameters.
+func (d *Dispatch) Call(method string, params ...interface{}) (result *VARIANT, err error) {
+	id, err := d.GetId(method)
+	if err != nil {
+		return
+	}
+
+	result, err = d.Invoke(id, DISPATCH_METHOD, params)
+	return
+}
+
+// MustCall method on IDispatch with parameters.
+func (d *Dispatch) MustCall(method string, params ...interface{}) (result *VARIANT) {
+	id, err := d.GetId(method)
+	if err != nil {
+		panic(err)
+	}
+
+	result, err = d.Invoke(id, DISPATCH_METHOD, params)
+	if err != nil {
+		panic(err)
+	}
+
+	return
+}
+
+// Get property on IDispatch with parameters.
+func (d *Dispatch) Get(name string, params ...interface{}) (result *VARIANT, err error) {
+	id, err := d.GetId(name)
+	if err != nil {
+		return
+	}
+	result, err = d.Invoke(id, DISPATCH_PROPERTYGET, params)
+	return
+}
+
+// MustGet property on IDispatch with parameters.
+func (d *Dispatch) MustGet(name string, params ...interface{}) (result *VARIANT) {
+	id, err := d.GetId(name)
+	if err != nil {
+		panic(err)
+	}
+
+	result, err = d.Invoke(id, DISPATCH_PROPERTYGET, params)
+	if err != nil {
+		panic(err)
+	}
+	return
+}
+
+// Set property on IDispatch with parameters.
+func (d *Dispatch) Set(name string, params ...interface{}) (result *VARIANT, err error) {
+	id, err := d.GetId(name)
+	if err != nil {
+		return
+	}
+	result, err = d.Invoke(id, DISPATCH_PROPERTYPUT, params)
+	return
+}
+
+// MustSet property on IDispatch with parameters.
+func (d *Dispatch) MustSet(name string, params ...interface{}) (result *VARIANT) {
+	id, err := d.GetId(name)
+	if err != nil {
+		panic(err)
+	}
+
+	result, err = d.Invoke(id, DISPATCH_PROPERTYPUT, params)
+	if err != nil {
+		panic(err)
+	}
+	return
+}
+
+// GetId retrieves ID of name on IDispatch.
+func (d *Dispatch) GetId(name string) (id int32, err error) {
+	var dispid []int32
+	dispid, err = d.Object.GetIDsOfName([]string{name})
+	if err != nil {
+		return
+	}
+	id = dispid[0]
+	return
+}
+
+// GetIds retrieves all IDs of names on IDispatch.
+func (d *Dispatch) GetIds(names ...string) (dispid []int32, err error) {
+	dispid, err = d.Object.GetIDsOfName(names)
+	return
+}
+
+// Invoke IDispatch on DisplayID of dispatch type with parameters.
+//
+// There have been problems where if send cascading params..., it would error
+// out because the parameters would be empty.
+func (d *Dispatch) Invoke(id int32, dispatch int16, params []interface{}) (result *VARIANT, err error) {
+	if len(params) < 1 {
+		result, err = d.Object.Invoke(id, dispatch)
+	} else {
+		result, err = d.Object.Invoke(id, dispatch, params...)
+	}
+	return
+}
+
+// Release IDispatch object.
+func (d *Dispatch) Release() {
+	d.Object.Release()
+}
+
+// Connect initializes COM and attempts to load IUnknown based on given names.
+func Connect(names ...string) (connection *Connection) {
+	connection.Initialize()
+	connection.Load(names...)
+	return
+}

vendor/github.com/go-ole/go-ole/constants.go

@@ -0,0 +1,153 @@
+package ole
+
+const (
+	CLSCTX_INPROC_SERVER   = 1
+	CLSCTX_INPROC_HANDLER  = 2
+	CLSCTX_LOCAL_SERVER    = 4
+	CLSCTX_INPROC_SERVER16 = 8
+	CLSCTX_REMOTE_SERVER   = 16
+	CLSCTX_ALL             = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER | CLSCTX_LOCAL_SERVER
+	CLSCTX_INPROC          = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER
+	CLSCTX_SERVER          = CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER
+)
+
+const (
+	COINIT_APARTMENTTHREADED = 0x2
+	COINIT_MULTITHREADED     = 0x0
+	COINIT_DISABLE_OLE1DDE   = 0x4
+	COINIT_SPEED_OVER_MEMORY = 0x8
+)
+
+const (
+	DISPATCH_METHOD         = 1
+	DISPATCH_PROPERTYGET    = 2
+	DISPATCH_PROPERTYPUT    = 4
+	DISPATCH_PROPERTYPUTREF = 8
+)
+
+const (
+	S_OK           = 0x00000000
+	E_UNEXPECTED   = 0x8000FFFF
+	E_NOTIMPL      = 0x80004001
+	E_OUTOFMEMORY  = 0x8007000E
+	E_INVALIDARG   = 0x80070057
+	E_NOINTERFACE  = 0x80004002
+	E_POINTER      = 0x80004003
+	E_HANDLE       = 0x80070006
+	E_ABORT        = 0x80004004
+	E_FAIL         = 0x80004005
+	E_ACCESSDENIED = 0x80070005
+	E_PENDING      = 0x8000000A
+
+	CO_E_CLASSSTRING = 0x800401F3
+)
+
+const (
+	CC_FASTCALL = iota
+	CC_CDECL
+	CC_MSCPASCAL
+	CC_PASCAL = CC_MSCPASCAL
+	CC_MACPASCAL
+	CC_STDCALL
+	CC_FPFASTCALL
+	CC_SYSCALL
+	CC_MPWCDECL
+	CC_MPWPASCAL
+	CC_MAX = CC_MPWPASCAL
+)
+
+type VT uint16
+
+const (
+	VT_EMPTY           VT = 0x0
+	VT_NULL            VT = 0x1
+	VT_I2              VT = 0x2
+	VT_I4              VT = 0x3
+	VT_R4              VT = 0x4
+	VT_R8              VT = 0x5
+	VT_CY              VT = 0x6
+	VT_DATE            VT = 0x7
+	VT_BSTR            VT = 0x8
+	VT_DISPATCH        VT = 0x9
+	VT_ERROR           VT = 0xa
+	VT_BOOL            VT = 0xb
+	VT_VARIANT         VT = 0xc
+	VT_UNKNOWN         VT = 0xd
+	VT_DECIMAL         VT = 0xe
+	VT_I1              VT = 0x10
+	VT_UI1             VT = 0x11
+	VT_UI2             VT = 0x12
+	VT_UI4             VT = 0x13
+	VT_I8              VT = 0x14
+	VT_UI8             VT = 0x15
+	VT_INT             VT = 0x16
+	VT_UINT            VT = 0x17
+	VT_VOID            VT = 0x18
+	VT_HRESULT         VT = 0x19
+	VT_PTR             VT = 0x1a
+	VT_SAFEARRAY       VT = 0x1b
+	VT_CARRAY          VT = 0x1c
+	VT_USERDEFINED     VT = 0x1d
+	VT_LPSTR           VT = 0x1e
+	VT_LPWSTR          VT = 0x1f
+	VT_RECORD          VT = 0x24
+	VT_INT_PTR         VT = 0x25
+	VT_UINT_PTR        VT = 0x26
+	VT_FILETIME        VT = 0x40
+	VT_BLOB            VT = 0x41
+	VT_STREAM          VT = 0x42
+	VT_STORAGE         VT = 0x43
+	VT_STREAMED_OBJECT VT = 0x44
+	VT_STORED_OBJECT   VT = 0x45
+	VT_BLOB_OBJECT     VT = 0x46
+	VT_CF              VT = 0x47
+	VT_CLSID           VT = 0x48
+	VT_BSTR_BLOB       VT = 0xfff
+	VT_VECTOR          VT = 0x1000
+	VT_ARRAY           VT = 0x2000
+	VT_BYREF           VT = 0x4000
+	VT_RESERVED        VT = 0x8000
+	VT_ILLEGAL         VT = 0xffff
+	VT_ILLEGALMASKED   VT = 0xfff
+	VT_TYPEMASK        VT = 0xfff
+)
+
+const (
+	DISPID_UNKNOWN     = -1
+	DISPID_VALUE       = 0
+	DISPID_PROPERTYPUT = -3
+	DISPID_NEWENUM     = -4
+	DISPID_EVALUATE    = -5
+	DISPID_CONSTRUCTOR = -6
+	DISPID_DESTRUCTOR  = -7
+	DISPID_COLLECT     = -8
+)
+
+const (
+	TKIND_ENUM      = 1
+	TKIND_RECORD    = 2
+	TKIND_MODULE    = 3
+	TKIND_INTERFACE = 4
+	TKIND_DISPATCH  = 5
+	TKIND_COCLASS   = 6
+	TKIND_ALIAS     = 7
+	TKIND_UNION     = 8
+	TKIND_MAX       = 9
+)
+
+// Safe Array Feature Flags
+
+const (
+	FADF_AUTO        = 0x0001
+	FADF_STATIC      = 0x0002
+	FADF_EMBEDDED    = 0x0004
+	FADF_FIXEDSIZE   = 0x0010
+	FADF_RECORD      = 0x0020
+	FADF_HAVEIID     = 0x0040
+	FADF_HAVEVARTYPE = 0x0080
+	FADF_BSTR        = 0x0100
+	FADF_UNKNOWN     = 0x0200
+	FADF_DISPATCH    = 0x0400
+	FADF_VARIANT     = 0x0800
+	FADF_RESERVED    = 0xF008
+)

vendor/github.com/go-ole/go-ole/error.go

@@ -0,0 +1,51 @@
+package ole
+
+// OleError stores COM errors.
+type OleError struct {
+	hr          uintptr
+	description string
+	subError    error
+}
+
+// NewError creates new error with HResult.
+func NewError(hr uintptr) *OleError {
+	return &OleError{hr: hr}
+}
+
+// NewErrorWithDescription creates new COM error with HResult and description.
+func NewErrorWithDescription(hr uintptr, description string) *OleError {
+	return &OleError{hr: hr, description: description}
+}
+
+// NewErrorWithSubError creates new COM error with parent error.
+func NewErrorWithSubError(hr uintptr, description string, err error) *OleError {
+	return &OleError{hr: hr, description: description, subError: err}
+}
+
+// Code is the HResult.
+func (v *OleError) Code() uintptr {
+	return uintptr(v.hr)
+}
+
+// String description, either manually set or format message with error code.
+func (v *OleError) String() string {
+	if v.description != "" {
+		return errstr(int(v.hr)) + " (" + v.description + ")"
+	}
+	return errstr(int(v.hr))
+}
+
+// Error implements error interface.
+func (v *OleError) Error() string {
+	return v.String()
+}
+
+// Description retrieves error summary, if there is one.
+func (v *OleError) Description() string {
+	return v.description
+}
+
+// SubError returns parent error, if there is one.
+func (v *OleError) SubError() error {
+	return v.subError
+}

vendor/github.com/go-ole/go-ole/error_func.go

@@ -0,0 +1,8 @@
+// +build !windows
+
+package ole
+
+// errstr converts error code to string.
+func errstr(errno int) string {
+	return ""
+}

vendor/github.com/go-ole/go-ole/error_windows.go

@@ -0,0 +1,24 @@
+// +build windows
+
+package ole
+
+import (
+	"fmt"
+	"syscall"
+	"unicode/utf16"
+)
+
+// errstr converts error code to string.
+func errstr(errno int) string {
+	// ask windows for the remaining errors
+	var flags uint32 = syscall.FORMAT_MESSAGE_FROM_SYSTEM | syscall.FORMAT_MESSAGE_ARGUMENT_ARRAY | syscall.FORMAT_MESSAGE_IGNORE_INSERTS
+	b := make([]uint16, 300)
+	n, err := syscall.FormatMessage(flags, 0, uint32(errno), 0, b, nil)
+	if err != nil {
+		return fmt.Sprintf("error %d (FormatMessage failed with: %v)", errno, err)
+	}
+	// trim terminating \r and \n
+	for ; n > 0 && (b[n-1] == '\n' || b[n-1] == '\r'); n-- {
+	}
+	return string(utf16.Decode(b[:n]))
+}

vendor/github.com/go-ole/go-ole/guid.go

@@ -0,0 +1,284 @@
+package ole
+
+var (
+	// IID_NULL is null Interface ID, used when no other Interface ID is known.
+	IID_NULL = NewGUID("{00000000-0000-0000-0000-000000000000}")
+
+	// IID_IUnknown is for IUnknown interfaces.
+	IID_IUnknown = NewGUID("{00000000-0000-0000-C000-000000000046}")
+
+	// IID_IDispatch is for IDispatch interfaces.
+	IID_IDispatch = NewGUID("{00020400-0000-0000-C000-000000000046}")
+
+	// IID_IEnumVariant is for IEnumVariant interfaces
+	IID_IEnumVariant = NewGUID("{00020404-0000-0000-C000-000000000046}")
+
+	// IID_IConnectionPointContainer is for IConnectionPointContainer interfaces.
+	IID_IConnectionPointContainer = NewGUID("{B196B284-BAB4-101A-B69C-00AA00341D07}")
+
+	// IID_IConnectionPoint is for IConnectionPoint interfaces.
+	IID_IConnectionPoint = NewGUID("{B196B286-BAB4-101A-B69C-00AA00341D07}")
+
+	// IID_IInspectable is for IInspectable interfaces.
+	IID_IInspectable = NewGUID("{AF86E2E0-B12D-4C6A-9C5A-D7AA65101E90}")
+
+	// IID_IProvideClassInfo is for IProvideClassInfo interfaces.
+	IID_IProvideClassInfo = NewGUID("{B196B283-BAB4-101A-B69C-00AA00341D07}")
+)
+
+// These are for testing and not part of any library.
+var (
+	// IID_ICOMTestString is for ICOMTestString interfaces.
+	//
+	// {E0133EB4-C36F-469A-9D3D-C66B84BE19ED}
+	IID_ICOMTestString = NewGUID("{E0133EB4-C36F-469A-9D3D-C66B84BE19ED}")
+
+	// IID_ICOMTestInt8 is for ICOMTestInt8 interfaces.
+	//
+	// {BEB06610-EB84-4155-AF58-E2BFF53680B4}
+	IID_ICOMTestInt8 = NewGUID("{BEB06610-EB84-4155-AF58-E2BFF53680B4}")
+
+	// IID_ICOMTestInt16 is for ICOMTestInt16 interfaces.
+	//
+	// {DAA3F9FA-761E-4976-A860-8364CE55F6FC}
+	IID_ICOMTestInt16 = NewGUID("{DAA3F9FA-761E-4976-A860-8364CE55F6FC}")
+
+	// IID_ICOMTestInt32 is for ICOMTestInt32 interfaces.
+	//
+	// {E3DEDEE7-38A2-4540-91D1-2EEF1D8891B0}
+	IID_ICOMTestInt32 = NewGUID("{E3DEDEE7-38A2-4540-91D1-2EEF1D8891B0}")
+
+	// IID_ICOMTestInt64 is for ICOMTestInt64 interfaces.
+	//
+	// {8D437CBC-B3ED-485C-BC32-C336432A1623}
+	IID_ICOMTestInt64 = NewGUID("{8D437CBC-B3ED-485C-BC32-C336432A1623}")
+
+	// IID_ICOMTestFloat is for ICOMTestFloat interfaces.
+	//
+	// {BF1ED004-EA02-456A-AA55-2AC8AC6B054C}
+	IID_ICOMTestFloat = NewGUID("{BF1ED004-EA02-456A-AA55-2AC8AC6B054C}")
+
+	// IID_ICOMTestDouble is for ICOMTestDouble interfaces.
+	//
+	// {BF908A81-8687-4E93-999F-D86FAB284BA0}
+	IID_ICOMTestDouble = NewGUID("{BF908A81-8687-4E93-999F-D86FAB284BA0}")
+
+	// IID_ICOMTestBoolean is for ICOMTestBoolean interfaces.
+	//
+	// {D530E7A6-4EE8-40D1-8931-3D63B8605010}
+	IID_ICOMTestBoolean = NewGUID("{D530E7A6-4EE8-40D1-8931-3D63B8605010}")
+
+	// IID_ICOMEchoTestObject is for ICOMEchoTestObject interfaces.
+	//
+	// {6485B1EF-D780-4834-A4FE-1EBB51746CA3}
+	IID_ICOMEchoTestObject = NewGUID("{6485B1EF-D780-4834-A4FE-1EBB51746CA3}")
+
+	// IID_ICOMTestTypes is for ICOMTestTypes interfaces.
+	//
+	// {CCA8D7AE-91C0-4277-A8B3-FF4EDF28D3C0}
+	IID_ICOMTestTypes = NewGUID("{CCA8D7AE-91C0-4277-A8B3-FF4EDF28D3C0}")
+
+	// CLSID_COMEchoTestObject is for COMEchoTestObject class.
+	//
+	// {3C24506A-AE9E-4D50-9157-EF317281F1B0}
+	CLSID_COMEchoTestObject = NewGUID("{3C24506A-AE9E-4D50-9157-EF317281F1B0}")
+
+	// CLSID_COMTestScalarClass is for COMTestScalarClass class.
+	//
+	// {865B85C5-0334-4AC6-9EF6-AACEC8FC5E86}
+	CLSID_COMTestScalarClass = NewGUID("{865B85C5-0334-4AC6-9EF6-AACEC8FC5E86}")
+)
+
+const hextable = "0123456789ABCDEF"
+const emptyGUID = "{00000000-0000-0000-0000-000000000000}"
+
+// GUID is Windows API specific GUID type.
+//
+// This exists to match Windows GUID type for direct passing for COM.
+// Format is in xxxxxxxx-xxxx-xxxx-xxxxxxxxxxxxxxxx.
+type GUID struct {
+	Data1 uint32
+	Data2 uint16
+	Data3 uint16
+	Data4 [8]byte
+}
+
+// NewGUID converts the given string into a globally unique identifier that is
+// compliant with the Windows API.
+//
+// The supplied string may be in any of these formats:
+//
+//  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+//  XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+//  {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}
+//
+// The conversion of the supplied string is not case-sensitive.
+func NewGUID(guid string) *GUID {
+	d := []byte(guid)
+	var d1, d2, d3, d4a, d4b []byte
+
+	switch len(d) {
+	case 38:
+		if d[0] != '{' || d[37] != '}' {
+			return nil
+		}
+		d = d[1:37]
+		fallthrough
+	case 36:
+		if d[8] != '-' || d[13] != '-' || d[18] != '-' || d[23] != '-' {
+			return nil
+		}
+		d1 = d[0:8]
+		d2 = d[9:13]
+		d3 = d[14:18]
+		d4a = d[19:23]
+		d4b = d[24:36]
+	case 32:
+		d1 = d[0:8]
+		d2 = d[8:12]
+		d3 = d[12:16]
+		d4a = d[16:20]
+		d4b = d[20:32]
+	default:
+		return nil
+	}
+
+	var g GUID
+	var ok1, ok2, ok3, ok4 bool
+	g.Data1, ok1 = decodeHexUint32(d1)
+	g.Data2, ok2 = decodeHexUint16(d2)
+	g.Data3, ok3 = decodeHexUint16(d3)
+	g.Data4, ok4 = decodeHexByte64(d4a, d4b)
+	if ok1 && ok2 && ok3 && ok4 {
+		return &g
+	}
+	return nil
+}
+
+func decodeHexUint32(src []byte) (value uint32, ok bool) {
+	var b1, b2, b3, b4 byte
+	var ok1, ok2, ok3, ok4 bool
+	b1, ok1 = decodeHexByte(src[0], src[1])
+	b2, ok2 = decodeHexByte(src[2], src[3])
+	b3, ok3 = decodeHexByte(src[4], src[5])
+	b4, ok4 = decodeHexByte(src[6], src[7])
+	value = (uint32(b1) << 24) | (uint32(b2) << 16) | (uint32(b3) << 8) | uint32(b4)
+	ok = ok1 && ok2 && ok3 && ok4
+	return
+}
+
+func decodeHexUint16(src []byte) (value uint16, ok bool) {
+	var b1, b2 byte
+	var ok1, ok2 bool
+	b1, ok1 = decodeHexByte(src[0], src[1])
+	b2, ok2 = decodeHexByte(src[2], src[3])
+	value = (uint16(b1) << 8) | uint16(b2)
+	ok = ok1 && ok2
+	return
+}
+
+func decodeHexByte64(s1 []byte, s2 []byte) (value [8]byte, ok bool) {
+	var ok1, ok2, ok3, ok4, ok5, ok6, ok7, ok8 bool
+	value[0], ok1 = decodeHexByte(s1[0], s1[1])
+	value[1], ok2 = decodeHexByte(s1[2], s1[3])
+	value[2], ok3 = decodeHexByte(s2[0], s2[1])
+	value[3], ok4 = decodeHexByte(s2[2], s2[3])
+	value[4], ok5 = decodeHexByte(s2[4], s2[5])
+	value[5], ok6 = decodeHexByte(s2[6], s2[7])
+	value[6], ok7 = decodeHexByte(s2[8], s2[9])
+	value[7], ok8 = decodeHexByte(s2[10], s2[11])
+	ok = ok1 && ok2 && ok3 && ok4 && ok5 && ok6 && ok7 && ok8
+	return
+}
+
+func decodeHexByte(c1, c2 byte) (value byte, ok bool) {
+	var n1, n2 byte
+	var ok1, ok2 bool
+	n1, ok1 = decodeHexChar(c1)
+	n2, ok2 = decodeHexChar(c2)
+	value = (n1 << 4) | n2
+	ok = ok1 && ok2
+	return
+}
+
+func decodeHexChar(c byte) (byte, bool) {
+	switch {
+	case '0' <= c && c <= '9':
+		return c - '0', true
+	case 'a' <= c && c <= 'f':
+		return c - 'a' + 10, true
+	case 'A' <= c && c <= 'F':
+		return c - 'A' + 10, true
+	}
+
+	return 0, false
+}
+
+// String converts the GUID to string form. It will adhere to this pattern:
+//
+//  {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}
+//
+// If the GUID is nil, the string representation of an empty GUID is returned:
+//
+//  {00000000-0000-0000-0000-000000000000}
+func (guid *GUID) String() string {
+	if guid == nil {
+		return emptyGUID
+	}
+
+	var c [38]byte
+	c[0] = '{'
+	putUint32Hex(c[1:9], guid.Data1)
+	c[9] = '-'
+	putUint16Hex(c[10:14], guid.Data2)
+	c[14] = '-'
+	putUint16Hex(c[15:19], guid.Data3)
+	c[19] = '-'
+	putByteHex(c[20:24], guid.Data4[0:2])
+	c[24] = '-'
+	putByteHex(c[25:37], guid.Data4[2:8])
+	c[37] = '}'
+	return string(c[:])
+}
+
+func putUint32Hex(b []byte, v uint32) {
+	b[0] = hextable[byte(v>>24)>>4]
+	b[1] = hextable[byte(v>>24)&0x0f]
+	b[2] = hextable[byte(v>>16)>>4]
+	b[3] = hextable[byte(v>>16)&0x0f]
+	b[4] = hextable[byte(v>>8)>>4]
+	b[5] = hextable[byte(v>>8)&0x0f]
+	b[6] = hextable[byte(v)>>4]
+	b[7] = hextable[byte(v)&0x0f]
+}
+
+func putUint16Hex(b []byte, v uint16) {
+	b[0] = hextable[byte(v>>8)>>4]
+	b[1] = hextable[byte(v>>8)&0x0f]
+	b[2] = hextable[byte(v)>>4]
+	b[3] = hextable[byte(v)&0x0f]
+}
+
+func putByteHex(dst, src []byte) {
+	for i := 0; i < len(src); i++ {
+		dst[i*2] = hextable[src[i]>>4]
+		dst[i*2+1] = hextable[src[i]&0x0f]
+	}
+}
+
+// IsEqualGUID compares two GUID.
+//
+// Not constant time comparison.
+func IsEqualGUID(guid1 *GUID, guid2 *GUID) bool {
+	return guid1.Data1 == guid2.Data1 &&
+		guid1.Data2 == guid2.Data2 &&
+		guid1.Data3 == guid2.Data3 &&
+		guid1.Data4[0] == guid2.Data4[0] &&
+		guid1.Data4[1] == guid2.Data4[1] &&
+		guid1.Data4[2] == guid2.Data4[2] &&
+		guid1.Data4[3] == guid2.Data4[3] &&
+		guid1.Data4[4] == guid2.Data4[4] &&
+		guid1.Data4[5] == guid2.Data4[5] &&
+		guid1.Data4[6] == guid2.Data4[6] &&
+		guid1.Data4[7] == guid2.Data4[7]
+}

vendor/github.com/go-ole/go-ole/iconnectionpoint.go

@@ -0,0 +1,20 @@
+package ole
+
+import "unsafe"
+
+type IConnectionPoint struct {
+	IUnknown
+}
+
+type IConnectionPointVtbl struct {
+	IUnknownVtbl
+	GetConnectionInterface      uintptr
+	GetConnectionPointContainer uintptr
+	Advise                      uintptr
+	Unadvise                    uintptr
+	EnumConnections             uintptr
+}
+
+func (v *IConnectionPoint) VTable() *IConnectionPointVtbl {
+	return (*IConnectionPointVtbl)(unsafe.Pointer(v.RawVTable))
+}

vendor/github.com/go-ole/go-ole/iconnectionpoint_func.go

@@ -0,0 +1,21 @@
+// +build !windows
+
+package ole
+
+import "unsafe"
+
+func (v *IConnectionPoint) GetConnectionInterface(piid **GUID) int32 {
+	return int32(0)
+}
+
+func (v *IConnectionPoint) Advise(unknown *IUnknown) (uint32, error) {
+	return uint32(0), NewError(E_NOTIMPL)
+}
+
+func (v *IConnectionPoint) Unadvise(cookie uint32) error {
+	return NewError(E_NOTIMPL)
+}
+
+func (v *IConnectionPoint) EnumConnections(p *unsafe.Pointer) (err error) {
+	return NewError(E_NOTIMPL)
+}

vendor/github.com/go-ole/go-ole/iconnectionpoint_windows.go

@@ -0,0 +1,43 @@
+// +build windows
+
+package ole
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+func (v *IConnectionPoint) GetConnectionInterface(piid **GUID) int32 {
+	// XXX: This doesn't look like it does what it's supposed to
+	return release((*IUnknown)(unsafe.Pointer(v)))
+}
+
+func (v *IConnectionPoint) Advise(unknown *IUnknown) (cookie uint32, err error) {
+	hr, _, _ := syscall.Syscall(
+		v.VTable().Advise,
+		3,
+		uintptr(unsafe.Pointer(v)),
+		uintptr(unsafe.Pointer(unknown)),
+		uintptr(unsafe.Pointer(&cookie)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func (v *IConnectionPoint) Unadvise(cookie uint32) (err error) {
+	hr, _, _ := syscall.Syscall(
+		v.VTable().Unadvise,
+		2,
+		uintptr(unsafe.Pointer(v)),
+		uintptr(cookie),
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func (v *IConnectionPoint) EnumConnections(p *unsafe.Pointer) error {
+	return NewError(E_NOTIMPL)
+}

vendor/github.com/go-ole/go-ole/iconnectionpointcontainer.go

@@ -0,0 +1,17 @@
+package ole
+
+import "unsafe"
+
+type IConnectionPointContainer struct {
+	IUnknown
+}
+
+type IConnectionPointContainerVtbl struct {
+	IUnknownVtbl
+	EnumConnectionPoints uintptr
+	FindConnectionPoint  uintptr
+}
+
+func (v *IConnectionPointContainer) VTable() *IConnectionPointContainerVtbl {
+	return (*IConnectionPointContainerVtbl)(unsafe.Pointer(v.RawVTable))
+}

vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_func.go

@@ -0,0 +1,11 @@
+// +build !windows
+
+package ole
+
+func (v *IConnectionPointContainer) EnumConnectionPoints(points interface{}) error {
+	return NewError(E_NOTIMPL)
+}
+
+func (v *IConnectionPointContainer) FindConnectionPoint(iid *GUID, point **IConnectionPoint) error {
+	return NewError(E_NOTIMPL)
+}

vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_windows.go

@@ -0,0 +1,25 @@
+// +build windows
+
+package ole
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+func (v *IConnectionPointContainer) EnumConnectionPoints(points interface{}) error {
+	return NewError(E_NOTIMPL)
+}
+
+func (v *IConnectionPointContainer) FindConnectionPoint(iid *GUID, point **IConnectionPoint) (err error) {
+	hr, _, _ := syscall.Syscall(
+		v.VTable().FindConnectionPoint,
+		3,
+		uintptr(unsafe.Pointer(v)),
+		uintptr(unsafe.Pointer(iid)),
+		uintptr(unsafe.Pointer(point)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}

vendor/github.com/go-ole/go-ole/idispatch.go

@@ -0,0 +1,94 @@
+package ole
+
+import "unsafe"
+
+type IDispatch struct {
+	IUnknown
+}
+
+type IDispatchVtbl struct {
+	IUnknownVtbl
+	GetTypeInfoCount uintptr
+	GetTypeInfo      uintptr
+	GetIDsOfNames    uintptr
+	Invoke           uintptr
+}
+
+func (v *IDispatch) VTable() *IDispatchVtbl {
+	return (*IDispatchVtbl)(unsafe.Pointer(v.RawVTable))
+}
+
+func (v *IDispatch) GetIDsOfName(names []string) (dispid []int32, err error) {
+	dispid, err = getIDsOfName(v, names)
+	return
+}
+
+func (v *IDispatch) Invoke(dispid int32, dispatch int16, params ...interface{}) (result *VARIANT, err error) {
+	result, err = invoke(v, dispid, dispatch, params...)
+	return
+}
+
+func (v *IDispatch) GetTypeInfoCount() (c uint32, err error) {
+	c, err = getTypeInfoCount(v)
+	return
+}
+
+func (v *IDispatch) GetTypeInfo() (tinfo *ITypeInfo, err error) {
+	tinfo, err = getTypeInfo(v)
+	return
+}
+
+// GetSingleIDOfName is a helper that returns single display ID for IDispatch name.
+//
+// This replaces the common pattern of attempting to get a single name from the list of available
+// IDs. It gives the first ID, if it is available.
+func (v *IDispatch) GetSingleIDOfName(name string) (displayID int32, err error) {
+	var displayIDs []int32
+	displayIDs, err = v.GetIDsOfName([]string{name})
+	if err != nil {
+		return
+	}
+	displayID = displayIDs[0]
+	return
+}
+
+// InvokeWithOptionalArgs accepts arguments as an array, works like Invoke.
+//
+// Accepts name and will attempt to retrieve Display ID to pass to Invoke.
+//
+// Passing params as an array is a workaround that could be fixed in later versions of Go that
+// prevent passing empty params. During testing it was discovered that this is an acceptable way of
+// getting around not being able to pass params normally.
+func (v *IDispatch) InvokeWithOptionalArgs(name string, dispatch int16, params []interface{}) (result *VARIANT, err error) {
+	displayID, err := v.GetSingleIDOfName(name)
+	if err != nil {
+		return
+	}
+
+	if len(params) < 1 {
+		result, err = v.Invoke(displayID, dispatch)
+	} else {
+		result, err = v.Invoke(displayID, dispatch, params...)
+	}
+
+	return
+}
+
+// CallMethod invokes named function with arguments on object.
+func (v *IDispatch) CallMethod(name string, params ...interface{}) (*VARIANT, error) {
+	return v.InvokeWithOptionalArgs(name, DISPATCH_METHOD, params)
+}
+
+// GetProperty retrieves the property with the name with the ability to pass arguments.
+//
+// Most of the time you will not need to pass arguments as most objects do not allow for this
+// feature. Or at least, should not allow for this feature. Some servers don't follow best practices
+// and this is provided for those edge cases.
+func (v *IDispatch) GetProperty(name string, params ...interface{}) (*VARIANT, error) {
+	return v.InvokeWithOptionalArgs(name, DISPATCH_PROPERTYGET, params)
+}
+
+// PutProperty attempts to mutate a property in the object.
+func (v *IDispatch) PutProperty(name string, params ...interface{}) (*VARIANT, error) {
+	return v.InvokeWithOptionalArgs(name, DISPATCH_PROPERTYPUT, params)
+}

vendor/github.com/go-ole/go-ole/idispatch_func.go

@@ -0,0 +1,19 @@
+// +build !windows
+
+package ole
+
+func getIDsOfName(disp *IDispatch, names []string) ([]int32, error) {
+	return []int32{}, NewError(E_NOTIMPL)
+}
+
+func getTypeInfoCount(disp *IDispatch) (uint32, error) {
+	return uint32(0), NewError(E_NOTIMPL)
+}
+
+func getTypeInfo(disp *IDispatch) (*ITypeInfo, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+func invoke(disp *IDispatch, dispid int32, dispatch int16, params ...interface{}) (*VARIANT, error) {
+	return nil, NewError(E_NOTIMPL)
+}

vendor/github.com/go-ole/go-ole/idispatch_windows.go

@@ -0,0 +1,197 @@
+// +build windows
+
+package ole
+
+import (
+	"syscall"
+	"time"
+	"unsafe"
+)
+
+func getIDsOfName(disp *IDispatch, names []string) (dispid []int32, err error) {
+	wnames := make([]*uint16, len(names))
+	for i := 0; i < len(names); i++ {
+		wnames[i] = syscall.StringToUTF16Ptr(names[i])
+	}
+	dispid = make([]int32, len(names))
+	namelen := uint32(len(names))
+	hr, _, _ := syscall.Syscall6(
+		disp.VTable().GetIDsOfNames,
+		6,
+		uintptr(unsafe.Pointer(disp)),
+		uintptr(unsafe.Pointer(IID_NULL)),
+		uintptr(unsafe.Pointer(&wnames[0])),
+		uintptr(namelen),
+		uintptr(GetUserDefaultLCID()),
+		uintptr(unsafe.Pointer(&dispid[0])))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func getTypeInfoCount(disp *IDispatch) (c uint32, err error) {
+	hr, _, _ := syscall.Syscall(
+		disp.VTable().GetTypeInfoCount,
+		2,
+		uintptr(unsafe.Pointer(disp)),
+		uintptr(unsafe.Pointer(&c)),
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func getTypeInfo(disp *IDispatch) (tinfo *ITypeInfo, err error) {
+	hr, _, _ := syscall.Syscall(
+		disp.VTable().GetTypeInfo,
+		3,
+		uintptr(unsafe.Pointer(disp)),
+		uintptr(GetUserDefaultLCID()),
+		uintptr(unsafe.Pointer(&tinfo)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func invoke(disp *IDispatch, dispid int32, dispatch int16, params ...interface{}) (result *VARIANT, err error) {
+	var dispparams DISPPARAMS
+
+	if dispatch&DISPATCH_PROPERTYPUT != 0 {
+		dispnames := [1]int32{DISPID_PROPERTYPUT}
+		dispparams.rgdispidNamedArgs = uintptr(unsafe.Pointer(&dispnames[0]))
+		dispparams.cNamedArgs = 1
+	} else if dispatch&DISPATCH_PROPERTYPUTREF != 0 {
+		dispnames := [1]int32{DISPID_PROPERTYPUT}
+		dispparams.rgdispidNamedArgs = uintptr(unsafe.Pointer(&dispnames[0]))
+		dispparams.cNamedArgs = 1
+	}
+	var vargs []VARIANT
+	if len(params) > 0 {
+		vargs = make([]VARIANT, len(params))
+		for i, v := range params {
+			//n := len(params)-i-1
+			n := len(params) - i - 1
+			VariantInit(&vargs[n])
+			switch vv := v.(type) {
+			case bool:
+				if vv {
+					vargs[n] = NewVariant(VT_BOOL, 0xffff)
+				} else {
+					vargs[n] = NewVariant(VT_BOOL, 0)
+				}
+			case *bool:
+				vargs[n] = NewVariant(VT_BOOL|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*bool)))))
+			case uint8:
+				vargs[n] = NewVariant(VT_I1, int64(v.(uint8)))
+			case *uint8:
+				vargs[n] = NewVariant(VT_I1|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint8)))))
+			case int8:
+				vargs[n] = NewVariant(VT_I1, int64(v.(int8)))
+			case *int8:
+				vargs[n] = NewVariant(VT_I1|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint8)))))
+			case int16:
+				vargs[n] = NewVariant(VT_I2, int64(v.(int16)))
+			case *int16:
+				vargs[n] = NewVariant(VT_I2|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int16)))))
+			case uint16:
+				vargs[n] = NewVariant(VT_UI2, int64(v.(uint16)))
+			case *uint16:
+				vargs[n] = NewVariant(VT_UI2|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint16)))))
+			case int32:
+				vargs[n] = NewVariant(VT_I4, int64(v.(int32)))
+			case *int32:
+				vargs[n] = NewVariant(VT_I4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int32)))))
+			case uint32:
+				vargs[n] = NewVariant(VT_UI4, int64(v.(uint32)))
+			case *uint32:
+				vargs[n] = NewVariant(VT_UI4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint32)))))
+			case int64:
+				vargs[n] = NewVariant(VT_I8, int64(v.(int64)))
+			case *int64:
+				vargs[n] = NewVariant(VT_I8|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int64)))))
+			case uint64:
+				vargs[n] = NewVariant(VT_UI8, int64(uintptr(v.(uint64))))
+			case *uint64:
+				vargs[n] = NewVariant(VT_UI8|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint64)))))
+			case int:
+				vargs[n] = NewVariant(VT_I4, int64(v.(int)))
+			case *int:
+				vargs[n] = NewVariant(VT_I4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int)))))
+			case uint:
+				vargs[n] = NewVariant(VT_UI4, int64(v.(uint)))
+			case *uint:
+				vargs[n] = NewVariant(VT_UI4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint)))))
+			case float32:
+				vargs[n] = NewVariant(VT_R4, *(*int64)(unsafe.Pointer(&vv)))
+			case *float32:
+				vargs[n] = NewVariant(VT_R4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*float32)))))
+			case float64:
+				vargs[n] = NewVariant(VT_R8, *(*int64)(unsafe.Pointer(&vv)))
+			case *float64:
+				vargs[n] = NewVariant(VT_R8|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*float64)))))
+			case string:
+				vargs[n] = NewVariant(VT_BSTR, int64(uintptr(unsafe.Pointer(SysAllocStringLen(v.(string))))))
+			case *string:
+				vargs[n] = NewVariant(VT_BSTR|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*string)))))
+			case time.Time:
+				s := vv.Format("2006-01-02 15:04:05")
+				vargs[n] = NewVariant(VT_BSTR, int64(uintptr(unsafe.Pointer(SysAllocStringLen(s)))))
+			case *time.Time:
+				s := vv.Format("2006-01-02 15:04:05")
+				vargs[n] = NewVariant(VT_BSTR|VT_BYREF, int64(uintptr(unsafe.Pointer(&s))))
+			case *IDispatch:
+				vargs[n] = NewVariant(VT_DISPATCH, int64(uintptr(unsafe.Pointer(v.(*IDispatch)))))
+			case **IDispatch:
+				vargs[n] = NewVariant(VT_DISPATCH|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(**IDispatch)))))
+			case nil:
+				vargs[n] = NewVariant(VT_NULL, 0)
+			case *VARIANT:
+				vargs[n] = NewVariant(VT_VARIANT|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*VARIANT)))))
+			case []byte:
+				safeByteArray := safeArrayFromByteSlice(v.([]byte))
+				vargs[n] = NewVariant(VT_ARRAY|VT_UI1, int64(uintptr(unsafe.Pointer(safeByteArray))))
+				defer VariantClear(&vargs[n])
+			case []string:
+				safeByteArray := safeArrayFromStringSlice(v.([]string))
+				vargs[n] = NewVariant(VT_ARRAY|VT_BSTR, int64(uintptr(unsafe.Pointer(safeByteArray))))
+				defer VariantClear(&vargs[n])
+			default:
+				panic("unknown type")
+			}
+		}
+		dispparams.rgvarg = uintptr(unsafe.Pointer(&vargs[0]))
+		dispparams.cArgs = uint32(len(params))
+	}
+
+	result = new(VARIANT)
+	var excepInfo EXCEPINFO
+	VariantInit(result)
+	hr, _, _ := syscall.Syscall9(
+		disp.VTable().Invoke,
+		9,
+		uintptr(unsafe.Pointer(disp)),
+		uintptr(dispid),
+		uintptr(unsafe.Pointer(IID_NULL)),
+		uintptr(GetUserDefaultLCID()),
+		uintptr(dispatch),
+		uintptr(unsafe.Pointer(&dispparams)),
+		uintptr(unsafe.Pointer(result)),
+		uintptr(unsafe.Pointer(&excepInfo)),
+		0)
+	if hr != 0 {
+		err = NewErrorWithSubError(hr, BstrToString(excepInfo.bstrDescription), excepInfo)
+	}
+	for i, varg := range vargs {
+		n := len(params) - i - 1
+		if varg.VT == VT_BSTR && varg.Val != 0 {
+			SysFreeString(((*int16)(unsafe.Pointer(uintptr(varg.Val)))))
+		}
+		if varg.VT == (VT_BSTR|VT_BYREF) && varg.Val != 0 {
+			*(params[n].(*string)) = LpOleStrToString(*(**uint16)(unsafe.Pointer(uintptr(varg.Val))))
+		}
+	}
+	return
+}

vendor/github.com/go-ole/go-ole/ienumvariant.go

@@ -0,0 +1,19 @@
+package ole
+
+import "unsafe"
+
+type IEnumVARIANT struct {
+	IUnknown
+}
+
+type IEnumVARIANTVtbl struct {
+	IUnknownVtbl
+	Next  uintptr
+	Skip  uintptr
+	Reset uintptr
+	Clone uintptr
+}
+
+func (v *IEnumVARIANT) VTable() *IEnumVARIANTVtbl {
+	return (*IEnumVARIANTVtbl)(unsafe.Pointer(v.RawVTable))
+}

vendor/github.com/go-ole/go-ole/ienumvariant_func.go

@@ -0,0 +1,19 @@
+// +build !windows
+
+package ole
+
+func (enum *IEnumVARIANT) Clone() (*IEnumVARIANT, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+func (enum *IEnumVARIANT) Reset() error {
+	return NewError(E_NOTIMPL)
+}
+
+func (enum *IEnumVARIANT) Skip(celt uint) error {
+	return NewError(E_NOTIMPL)
+}
+
+func (enum *IEnumVARIANT) Next(celt uint) (VARIANT, uint, error) {
+	return NewVariant(VT_NULL, int64(0)), 0, NewError(E_NOTIMPL)
+}

vendor/github.com/go-ole/go-ole/ienumvariant_windows.go

@@ -0,0 +1,63 @@
+// +build windows
+
+package ole
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+func (enum *IEnumVARIANT) Clone() (cloned *IEnumVARIANT, err error) {
+	hr, _, _ := syscall.Syscall(
+		enum.VTable().Clone,
+		2,
+		uintptr(unsafe.Pointer(enum)),
+		uintptr(unsafe.Pointer(&cloned)),
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func (enum *IEnumVARIANT) Reset() (err error) {
+	hr, _, _ := syscall.Syscall(
+		enum.VTable().Reset,
+		1,
+		uintptr(unsafe.Pointer(enum)),
+		0,
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func (enum *IEnumVARIANT) Skip(celt uint) (err error) {
+	hr, _, _ := syscall.Syscall(
+		enum.VTable().Skip,
+		2,
+		uintptr(unsafe.Pointer(enum)),
+		uintptr(celt),
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func (enum *IEnumVARIANT) Next(celt uint) (array VARIANT, length uint, err error) {
+	hr, _, _ := syscall.Syscall6(
+		enum.VTable().Next,
+		4,
+		uintptr(unsafe.Pointer(enum)),
+		uintptr(celt),
+		uintptr(unsafe.Pointer(&array)),
+		uintptr(unsafe.Pointer(&length)),
+		0,
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}

vendor/github.com/go-ole/go-ole/iinspectable.go

@@ -0,0 +1,18 @@
+package ole
+
+import "unsafe"
+
+type IInspectable struct {
+	IUnknown
+}
+
+type IInspectableVtbl struct {
+	IUnknownVtbl
+	GetIIds             uintptr
+	GetRuntimeClassName uintptr
+	GetTrustLevel       uintptr
+}
+
+func (v *IInspectable) VTable() *IInspectableVtbl {
+	return (*IInspectableVtbl)(unsafe.Pointer(v.RawVTable))
+}

vendor/github.com/go-ole/go-ole/iinspectable_func.go

@@ -0,0 +1,15 @@
+// +build !windows
+
+package ole
+
+func (v *IInspectable) GetIids() ([]*GUID, error) {
+	return []*GUID{}, NewError(E_NOTIMPL)
+}
+
+func (v *IInspectable) GetRuntimeClassName() (string, error) {
+	return "", NewError(E_NOTIMPL)
+}
+
+func (v *IInspectable) GetTrustLevel() (uint32, error) {
+	return uint32(0), NewError(E_NOTIMPL)
+}

vendor/github.com/go-ole/go-ole/iinspectable_windows.go

@@ -0,0 +1,72 @@
+// +build windows
+
+package ole
+
+import (
+	"bytes"
+	"encoding/binary"
+	"reflect"
+	"syscall"
+	"unsafe"
+)
+
+func (v *IInspectable) GetIids() (iids []*GUID, err error) {
+	var count uint32
+	var array uintptr
+	hr, _, _ := syscall.Syscall(
+		v.VTable().GetIIds,
+		3,
+		uintptr(unsafe.Pointer(v)),
+		uintptr(unsafe.Pointer(&count)),
+		uintptr(unsafe.Pointer(&array)))
+	if hr != 0 {
+		err = NewError(hr)
+		return
+	}
+	defer CoTaskMemFree(array)
+
+	iids = make([]*GUID, count)
+	byteCount := count * uint32(unsafe.Sizeof(GUID{}))
+	slicehdr := reflect.SliceHeader{Data: array, Len: int(byteCount), Cap: int(byteCount)}
+	byteSlice := *(*[]byte)(unsafe.Pointer(&slicehdr))
+	reader := bytes.NewReader(byteSlice)
+	for i := range iids {
+		guid := GUID{}
+		err = binary.Read(reader, binary.LittleEndian, &guid)
+		if err != nil {
+			return
+		}
+		iids[i] = &guid
+	}
+	return
+}
+
+func (v *IInspectable) GetRuntimeClassName() (s string, err error) {
+	var hstring HString
+	hr, _, _ := syscall.Syscall(
+		v.VTable().GetRuntimeClassName,
+		2,
+		uintptr(unsafe.Pointer(v)),
+		uintptr(unsafe.Pointer(&hstring)),
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+		return
+	}
+	s = hstring.String()
+	DeleteHString(hstring)
+	return
+}
+
+func (v *IInspectable) GetTrustLevel() (level uint32, err error) {
+	hr, _, _ := syscall.Syscall(
+		v.VTable().GetTrustLevel,
+		2,
+		uintptr(unsafe.Pointer(v)),
+		uintptr(unsafe.Pointer(&level)),
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}

vendor/github.com/go-ole/go-ole/iprovideclassinfo.go

@@ -0,0 +1,21 @@
+package ole
+
+import "unsafe"
+
+type IProvideClassInfo struct {
+	IUnknown
+}
+
+type IProvideClassInfoVtbl struct {
+	IUnknownVtbl
+	GetClassInfo uintptr
+}
+
+func (v *IProvideClassInfo) VTable() *IProvideClassInfoVtbl {
+	return (*IProvideClassInfoVtbl)(unsafe.Pointer(v.RawVTable))
+}
+
+func (v *IProvideClassInfo) GetClassInfo() (cinfo *ITypeInfo, err error) {
+	cinfo, err = getClassInfo(v)
+	return
+}

vendor/github.com/go-ole/go-ole/iprovideclassinfo_func.go

@@ -0,0 +1,7 @@
+// +build !windows
+
+package ole
+
+func getClassInfo(disp *IProvideClassInfo) (tinfo *ITypeInfo, err error) {
+	return nil, NewError(E_NOTIMPL)
+}

vendor/github.com/go-ole/go-ole/iprovideclassinfo_windows.go

@@ -0,0 +1,21 @@
+// +build windows
+
+package ole
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+func getClassInfo(disp *IProvideClassInfo) (tinfo *ITypeInfo, err error) {
+	hr, _, _ := syscall.Syscall(
+		disp.VTable().GetClassInfo,
+		2,
+		uintptr(unsafe.Pointer(disp)),
+		uintptr(unsafe.Pointer(&tinfo)),
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}

vendor/github.com/go-ole/go-ole/itypeinfo.go

@@ -0,0 +1,34 @@
+package ole
+
+import "unsafe"
+
+type ITypeInfo struct {
+	IUnknown
+}
+
+type ITypeInfoVtbl struct {
+	IUnknownVtbl
+	GetTypeAttr          uintptr
+	GetTypeComp          uintptr
+	GetFuncDesc          uintptr
+	GetVarDesc           uintptr
+	GetNames             uintptr
+	GetRefTypeOfImplType uintptr
+	GetImplTypeFlags     uintptr
+	GetIDsOfNames        uintptr
+	Invoke               uintptr
+	GetDocumentation     uintptr
+	GetDllEntry          uintptr
+	GetRefTypeInfo       uintptr
+	AddressOfMember      uintptr
+	CreateInstance       uintptr
+	GetMops              uintptr
+	GetContainingTypeLib uintptr
+	ReleaseTypeAttr      uintptr
+	ReleaseFuncDesc      uintptr
+	ReleaseVarDesc       uintptr
+}
+
+func (v *ITypeInfo) VTable() *ITypeInfoVtbl {
+	return (*ITypeInfoVtbl)(unsafe.Pointer(v.RawVTable))
+}

vendor/github.com/go-ole/go-ole/itypeinfo_func.go

@@ -0,0 +1,7 @@
+// +build !windows
+
+package ole
+
+func (v *ITypeInfo) GetTypeAttr() (*TYPEATTR, error) {
+	return nil, NewError(E_NOTIMPL)
+}

vendor/github.com/go-ole/go-ole/itypeinfo_windows.go

@@ -0,0 +1,21 @@
+// +build windows
+
+package ole
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+func (v *ITypeInfo) GetTypeAttr() (tattr *TYPEATTR, err error) {
+	hr, _, _ := syscall.Syscall(
+		uintptr(v.VTable().GetTypeAttr),
+		2,
+		uintptr(unsafe.Pointer(v)),
+		uintptr(unsafe.Pointer(&tattr)),
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}

vendor/github.com/go-ole/go-ole/iunknown.go

@@ -0,0 +1,57 @@
+package ole
+
+import "unsafe"
+
+type IUnknown struct {
+	RawVTable *interface{}
+}
+
+type IUnknownVtbl struct {
+	QueryInterface uintptr
+	AddRef         uintptr
+	Release        uintptr
+}
+
+type UnknownLike interface {
+	QueryInterface(iid *GUID) (disp *IDispatch, err error)
+	AddRef() int32
+	Release() int32
+}
+
+func (v *IUnknown) VTable() *IUnknownVtbl {
+	return (*IUnknownVtbl)(unsafe.Pointer(v.RawVTable))
+}
+
+func (v *IUnknown) PutQueryInterface(interfaceID *GUID, obj interface{}) error {
+	return reflectQueryInterface(v, v.VTable().QueryInterface, interfaceID, obj)
+}
+
+func (v *IUnknown) IDispatch(interfaceID *GUID) (dispatch *IDispatch, err error) {
+	err = v.PutQueryInterface(interfaceID, &dispatch)
+	return
+}
+
+func (v *IUnknown) IEnumVARIANT(interfaceID *GUID) (enum *IEnumVARIANT, err error) {
+	err = v.PutQueryInterface(interfaceID, &enum)
+	return
+}
+
+func (v *IUnknown) QueryInterface(iid *GUID) (*IDispatch, error) {
+	return queryInterface(v, iid)
+}
+
+func (v *IUnknown) MustQueryInterface(iid *GUID) (disp *IDispatch) {
+	unk, err := queryInterface(v, iid)
+	if err != nil {
+		panic(err)
+	}
+	return unk
+}
+
+func (v *IUnknown) AddRef() int32 {
+	return addRef(v)
+}
+
+func (v *IUnknown) Release() int32 {
+	return release(v)
+}

vendor/github.com/go-ole/go-ole/iunknown_func.go

@@ -0,0 +1,19 @@
+// +build !windows
+
+package ole
+
+func reflectQueryInterface(self interface{}, method uintptr, interfaceID *GUID, obj interface{}) (err error) {
+	return NewError(E_NOTIMPL)
+}
+
+func queryInterface(unk *IUnknown, iid *GUID) (disp *IDispatch, err error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+func addRef(unk *IUnknown) int32 {
+	return 0
+}
+
+func release(unk *IUnknown) int32 {
+	return 0
+}

vendor/github.com/go-ole/go-ole/iunknown_windows.go

@@ -0,0 +1,58 @@
+// +build windows
+
+package ole
+
+import (
+	"reflect"
+	"syscall"
+	"unsafe"
+)
+
+func reflectQueryInterface(self interface{}, method uintptr, interfaceID *GUID, obj interface{}) (err error) {
+	selfValue := reflect.ValueOf(self).Elem()
+	objValue := reflect.ValueOf(obj).Elem()
+
+	hr, _, _ := syscall.Syscall(
+		method,
+		3,
+		selfValue.UnsafeAddr(),
+		uintptr(unsafe.Pointer(interfaceID)),
+		objValue.Addr().Pointer())
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func queryInterface(unk *IUnknown, iid *GUID) (disp *IDispatch, err error) {
+	hr, _, _ := syscall.Syscall(
+		unk.VTable().QueryInterface,
+		3,
+		uintptr(unsafe.Pointer(unk)),
+		uintptr(unsafe.Pointer(iid)),
+		uintptr(unsafe.Pointer(&disp)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func addRef(unk *IUnknown) int32 {
+	ret, _, _ := syscall.Syscall(
+		unk.VTable().AddRef,
+		1,
+		uintptr(unsafe.Pointer(unk)),
+		0,
+		0)
+	return int32(ret)
+}
+
+func release(unk *IUnknown) int32 {
+	ret, _, _ := syscall.Syscall(
+		unk.VTable().Release,
+		1,
+		uintptr(unsafe.Pointer(unk)),
+		0,
+		0)
+	return int32(ret)
+}

vendor/github.com/go-ole/go-ole/ole.go

@@ -0,0 +1,157 @@
+package ole
+
+import (
+	"fmt"
+	"strings"
+)
+
+// DISPPARAMS are the arguments that passed to methods or property.
+type DISPPARAMS struct {
+	rgvarg            uintptr
+	rgdispidNamedArgs uintptr
+	cArgs             uint32
+	cNamedArgs        uint32
+}
+
+// EXCEPINFO defines exception info.
+type EXCEPINFO struct {
+	wCode             uint16
+	wReserved         uint16
+	bstrSource        *uint16
+	bstrDescription   *uint16
+	bstrHelpFile      *uint16
+	dwHelpContext     uint32
+	pvReserved        uintptr
+	pfnDeferredFillIn uintptr
+	scode             uint32
+}
+
+// WCode return wCode in EXCEPINFO.
+func (e EXCEPINFO) WCode() uint16 {
+	return e.wCode
+}
+
+// SCODE return scode in EXCEPINFO.
+func (e EXCEPINFO) SCODE() uint32 {
+	return e.scode
+}
+
+// String convert EXCEPINFO to string.
+func (e EXCEPINFO) String() string {
+	var src, desc, hlp string
+	if e.bstrSource == nil {
+		src = "<nil>"
+	} else {
+		src = BstrToString(e.bstrSource)
+	}
+
+	if e.bstrDescription == nil {
+		desc = "<nil>"
+	} else {
+		desc = BstrToString(e.bstrDescription)
+	}
+
+	if e.bstrHelpFile == nil {
+		hlp = "<nil>"
+	} else {
+		hlp = BstrToString(e.bstrHelpFile)
+	}
+
+	return fmt.Sprintf(
+		"wCode: %#x, bstrSource: %v, bstrDescription: %v, bstrHelpFile: %v, dwHelpContext: %#x, scode: %#x",
+		e.wCode, src, desc, hlp, e.dwHelpContext, e.scode,
+	)
+}
+
+// Error implements error interface and returns error string.
+func (e EXCEPINFO) Error() string {
+	if e.bstrDescription != nil {
+		return strings.TrimSpace(BstrToString(e.bstrDescription))
+	}
+
+	src := "Unknown"
+	if e.bstrSource != nil {
+		src = BstrToString(e.bstrSource)
+	}
+
+	code := e.scode
+	if e.wCode != 0 {
+		code = uint32(e.wCode)
+	}
+
+	return fmt.Sprintf("%v: %#x", src, code)
+}
+
+// PARAMDATA defines parameter data type.
+type PARAMDATA struct {
+	Name *int16
+	Vt   uint16
+}
+
+// METHODDATA defines method info.
+type METHODDATA struct {
+	Name     *uint16
+	Data     *PARAMDATA
+	Dispid   int32
+	Meth     uint32
+	CC       int32
+	CArgs    uint32
+	Flags    uint16
+	VtReturn uint32
+}
+
+// INTERFACEDATA defines interface info.
+type INTERFACEDATA struct {
+	MethodData *METHODDATA
+	CMembers   uint32
+}
+
+// Point is 2D vector type.
+type Point struct {
+	X int32
+	Y int32
+}
+
+// Msg is message between processes.
+type Msg struct {
+	Hwnd    uint32
+	Message uint32
+	Wparam  int32
+	Lparam  int32
+	Time    uint32
+	Pt      Point
+}
+
+// TYPEDESC defines data type.
+type TYPEDESC struct {
+	Hreftype uint32
+	VT       uint16
+}
+
+// IDLDESC defines IDL info.
+type IDLDESC struct {
+	DwReserved uint32
+	WIDLFlags  uint16
+}
+
+// TYPEATTR defines type info.
+type TYPEATTR struct {
+	Guid             GUID
+	Lcid             uint32
+	dwReserved       uint32
+	MemidConstructor int32
+	MemidDestructor  int32
+	LpstrSchema      *uint16
+	CbSizeInstance   uint32
+	Typekind         int32
+	CFuncs           uint16
+	CVars            uint16
+	CImplTypes       uint16
+	CbSizeVft        uint16
+	CbAlignment      uint16
+	WTypeFlags       uint16
+	WMajorVerNum     uint16
+	WMinorVerNum     uint16
+	TdescAlias       TYPEDESC
+	IdldescType      IDLDESC
+}

vendor/github.com/go-ole/go-ole/oleutil/connection.go

@@ -0,0 +1,100 @@
+// +build windows
+
+package oleutil
+
+import (
+	"reflect"
+	"unsafe"
+
+	ole "github.com/go-ole/go-ole"
+)
+
+type stdDispatch struct {
+	lpVtbl  *stdDispatchVtbl
+	ref     int32
+	iid     *ole.GUID
+	iface   interface{}
+	funcMap map[string]int32
+}
+
+type stdDispatchVtbl struct {
+	pQueryInterface   uintptr
+	pAddRef           uintptr
+	pRelease          uintptr
+	pGetTypeInfoCount uintptr
+	pGetTypeInfo      uintptr
+	pGetIDsOfNames    uintptr
+	pInvoke           uintptr
+}
+
+func dispQueryInterface(this *ole.IUnknown, iid *ole.GUID, punk **ole.IUnknown) uint32 {
+	pthis := (*stdDispatch)(unsafe.Pointer(this))
+	*punk = nil
+	if ole.IsEqualGUID(iid, ole.IID_IUnknown) ||
+		ole.IsEqualGUID(iid, ole.IID_IDispatch) {
+		dispAddRef(this)
+		*punk = this
+		return ole.S_OK
+	}
+	if ole.IsEqualGUID(iid, pthis.iid) {
+		dispAddRef(this)
+		*punk = this
+		return ole.S_OK
+	}
+	return ole.E_NOINTERFACE
+}
+
+func dispAddRef(this *ole.IUnknown) int32 {
+	pthis := (*stdDispatch)(unsafe.Pointer(this))
+	pthis.ref++
+	return pthis.ref
+}
+
+func dispRelease(this *ole.IUnknown) int32 {
+	pthis := (*stdDispatch)(unsafe.Pointer(this))
+	pthis.ref--
+	return pthis.ref
+}
+
+func dispGetIDsOfNames(this *ole.IUnknown, iid *ole.GUID, wnames []*uint16, namelen int, lcid int, pdisp []int32) uintptr {
+	pthis := (*stdDispatch)(unsafe.Pointer(this))
+	names := make([]string, len(wnames))
+	for i := 0; i < len(names); i++ {
+		names[i] = ole.LpOleStrToString(wnames[i])
+	}
+	for n := 0; n < namelen; n++ {
+		if id, ok := pthis.funcMap[names[n]]; ok {
+			pdisp[n] = id
+		}
+	}
+	return ole.S_OK
+}
+
+func dispGetTypeInfoCount(pcount *int) uintptr {
+	if pcount != nil {
+		*pcount = 0
+	}
+	return ole.S_OK
+}
+
+func dispGetTypeInfo(ptypeif *uintptr) uintptr {
+	return ole.E_NOTIMPL
+}
+
+func dispInvoke(this *ole.IDispatch, dispid int32, riid *ole.GUID, lcid int, flags int16, dispparams *ole.DISPPARAMS, result *ole.VARIANT, pexcepinfo *ole.EXCEPINFO, nerr *uint) uintptr {
+	pthis := (*stdDispatch)(unsafe.Pointer(this))
+	found := ""
+	for name, id := range pthis.funcMap {
+		if id == dispid {
+			found = name
+		}
+	}
+	if found != "" {
+		rv := reflect.ValueOf(pthis.iface).Elem()
+		rm := rv.MethodByName(found)
+		rr := rm.Call([]reflect.Value{})
+		println(len(rr))
+		return ole.S_OK
+	}
+	return ole.E_NOTIMPL
+}

vendor/github.com/go-ole/go-ole/oleutil/connection_func.go

@@ -0,0 +1,10 @@
+// +build !windows
+
+package oleutil
+
+import ole "github.com/go-ole/go-ole"
+
+// ConnectObject creates a connection point between two services for communication.
+func ConnectObject(disp *ole.IDispatch, iid *ole.GUID, idisp interface{}) (uint32, error) {
+	return 0, ole.NewError(ole.E_NOTIMPL)
+}

vendor/github.com/go-ole/go-ole/oleutil/connection_windows.go

@@ -0,0 +1,58 @@
+// +build windows
+
+package oleutil
+
+import (
+	"reflect"
+	"syscall"
+	"unsafe"
+
+	ole "github.com/go-ole/go-ole"
+)
+
+// ConnectObject creates a connection point between two services for communication.
+func ConnectObject(disp *ole.IDispatch, iid *ole.GUID, idisp interface{}) (cookie uint32, err error) {
+	unknown, err := disp.QueryInterface(ole.IID_IConnectionPointContainer)
+	if err != nil {
+		return
+	}
+
+	container := (*ole.IConnectionPointContainer)(unsafe.Pointer(unknown))
+	var point *ole.IConnectionPoint
+	err = container.FindConnectionPoint(iid, &point)
+	if err != nil {
+		return
+	}
+	if edisp, ok := idisp.(*ole.IUnknown); ok {
+		cookie, err = point.Advise(edisp)
+		container.Release()
+		if err != nil {
+			return
+		}
+	}
+	rv := reflect.ValueOf(disp).Elem()
+	if rv.Type().Kind() == reflect.Struct {
+		dest := &stdDispatch{}
+		dest.lpVtbl = &stdDispatchVtbl{}
+		dest.lpVtbl.pQueryInterface = syscall.NewCallback(dispQueryInterface)
+		dest.lpVtbl.pAddRef = syscall.NewCallback(dispAddRef)
+		dest.lpVtbl.pRelease = syscall.NewCallback(dispRelease)
+		dest.lpVtbl.pGetTypeInfoCount = syscall.NewCallback(dispGetTypeInfoCount)
+		dest.lpVtbl.pGetTypeInfo = syscall.NewCallback(dispGetTypeInfo)
+		dest.lpVtbl.pGetIDsOfNames = syscall.NewCallback(dispGetIDsOfNames)
+		dest.lpVtbl.pInvoke = syscall.NewCallback(dispInvoke)
+		dest.iface = disp
+		dest.iid = iid
+		cookie, err = point.Advise((*ole.IUnknown)(unsafe.Pointer(dest)))
+		container.Release()
+		if err != nil {
+			point.Release()
+			return
+		}
+		return
+	}
+
+	container.Release()
+
+	return 0, ole.NewError(ole.E_INVALIDARG)
+}

vendor/github.com/go-ole/go-ole/oleutil/go-get.go

@@ -0,0 +1,6 @@
+// This file is here so go get succeeds as without it errors with:
+// no buildable Go source files in ...
+//
+// +build !windows
+
+package oleutil

vendor/github.com/go-ole/go-ole/oleutil/oleutil.go

@@ -0,0 +1,127 @@
+package oleutil
+
+import ole "github.com/go-ole/go-ole"
+
+// ClassIDFrom retrieves class ID whether given is program ID or application string.
+func ClassIDFrom(programID string) (classID *ole.GUID, err error) {
+	return ole.ClassIDFrom(programID)
+}
+
+// CreateObject creates object from programID based on interface type.
+//
+// Only supports IUnknown.
+//
+// Program ID can be either program ID or application string.
+func CreateObject(programID string) (unknown *ole.IUnknown, err error) {
+	classID, err := ole.ClassIDFrom(programID)
+	if err != nil {
+		return
+	}
+
+	unknown, err = ole.CreateInstance(classID, ole.IID_IUnknown)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// GetActiveObject retrieves active object for program ID and interface ID based
+// on interface type.
+//
+// Only supports IUnknown.
+//
+// Program ID can be either program ID or application string.
+func GetActiveObject(programID string) (unknown *ole.IUnknown, err error) {
+	classID, err := ole.ClassIDFrom(programID)
+	if err != nil {
+		return
+	}
+
+	unknown, err = ole.GetActiveObject(classID, ole.IID_IUnknown)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// CallMethod calls method on IDispatch with parameters.
+func CallMethod(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT, err error) {
+	return disp.InvokeWithOptionalArgs(name, ole.DISPATCH_METHOD, params)
+}
+
+// MustCallMethod calls method on IDispatch with parameters or panics.
+func MustCallMethod(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT) {
+	r, err := CallMethod(disp, name, params...)
+	if err != nil {
+		panic(err.Error())
+	}
+	return r
+}
+
+// GetProperty retrieves property from IDispatch.
+func GetProperty(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT, err error) {
+	return disp.InvokeWithOptionalArgs(name, ole.DISPATCH_PROPERTYGET, params)
+}
+
+// MustGetProperty retrieves property from IDispatch or panics.
+func MustGetProperty(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT) {
+	r, err := GetProperty(disp, name, params...)
+	if err != nil {
+		panic(err.Error())
+	}
+	return r
+}
+
+// PutProperty mutates property.
+func PutProperty(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT, err error) {
+	return disp.InvokeWithOptionalArgs(name, ole.DISPATCH_PROPERTYPUT, params)
+}
+
+// MustPutProperty mutates property or panics.
+func MustPutProperty(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT) {
+	r, err := PutProperty(disp, name, params...)
+	if err != nil {
+		panic(err.Error())
+	}
+	return r
+}
+
+// PutPropertyRef mutates property reference.
+func PutPropertyRef(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT, err error) {
+	return disp.InvokeWithOptionalArgs(name, ole.DISPATCH_PROPERTYPUTREF, params)
+}
+
+// MustPutPropertyRef mutates property reference or panics.
+func MustPutPropertyRef(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT) {
+	r, err := PutPropertyRef(disp, name, params...)
+	if err != nil {
+		panic(err.Error())
+	}
+	return r
+}
+
+func ForEach(disp *ole.IDispatch, f func(v *ole.VARIANT) error) error {
+	newEnum, err := disp.GetProperty("_NewEnum")
+	if err != nil {
+		return err
+	}
+	defer newEnum.Clear()
+
+	enum, err := newEnum.ToIUnknown().IEnumVARIANT(ole.IID_IEnumVariant)
+	if err != nil {
+		return err
+	}
+	defer enum.Release()
+
+	for item, length, err := enum.Next(1); length > 0; item, length, err = enum.Next(1) {
+		if err != nil {
+			return err
+		}
+		if ferr := f(&item); ferr != nil {
+			return ferr
+		}
+	}
+	return nil
+}

vendor/github.com/go-ole/go-ole/safearray.go

@@ -0,0 +1,27 @@
+// Package is meant to retrieve and process safe array data returned from COM.
+
+package ole
+
+// SafeArrayBound defines the SafeArray boundaries.
+type SafeArrayBound struct {
+	Elements   uint32
+	LowerBound int32
+}
+
+// SafeArray is how COM handles arrays.
+type SafeArray struct {
+	Dimensions   uint16
+	FeaturesFlag uint16
+	ElementsSize uint32
+	LocksAmount  uint32
+	Data         uint32
+	Bounds       [16]byte
+}
+
+// SAFEARRAY is obsolete, exists for backwards compatibility.
+// Use SafeArray
+type SAFEARRAY SafeArray
+
+// SAFEARRAYBOUND is obsolete, exists for backwards compatibility.
+// Use SafeArrayBound
+type SAFEARRAYBOUND SafeArrayBound

vendor/github.com/go-ole/go-ole/safearray_func.go

@@ -0,0 +1,211 @@
+// +build !windows
+
+package ole
+
+import (
+	"unsafe"
+)
+
+// safeArrayAccessData returns raw array pointer.
+//
+// AKA: SafeArrayAccessData in Windows API.
+func safeArrayAccessData(safearray *SafeArray) (uintptr, error) {
+	return uintptr(0), NewError(E_NOTIMPL)
+}
+
+// safeArrayUnaccessData releases raw array.
+//
+// AKA: SafeArrayUnaccessData in Windows API.
+func safeArrayUnaccessData(safearray *SafeArray) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayAllocData allocates SafeArray.
+//
+// AKA: SafeArrayAllocData in Windows API.
+func safeArrayAllocData(safearray *SafeArray) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayAllocDescriptor allocates SafeArray.
+//
+// AKA: SafeArrayAllocDescriptor in Windows API.
+func safeArrayAllocDescriptor(dimensions uint32) (*SafeArray, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArrayAllocDescriptorEx allocates SafeArray.
+//
+// AKA: SafeArrayAllocDescriptorEx in Windows API.
+func safeArrayAllocDescriptorEx(variantType VT, dimensions uint32) (*SafeArray, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArrayCopy returns copy of SafeArray.
+//
+// AKA: SafeArrayCopy in Windows API.
+func safeArrayCopy(original *SafeArray) (*SafeArray, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArrayCopyData duplicates SafeArray into another SafeArray object.
+//
+// AKA: SafeArrayCopyData in Windows API.
+func safeArrayCopyData(original *SafeArray, duplicate *SafeArray) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayCreate creates SafeArray.
+//
+// AKA: SafeArrayCreate in Windows API.
+func safeArrayCreate(variantType VT, dimensions uint32, bounds *SafeArrayBound) (*SafeArray, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArrayCreateEx creates SafeArray.
+//
+// AKA: SafeArrayCreateEx in Windows API.
+func safeArrayCreateEx(variantType VT, dimensions uint32, bounds *SafeArrayBound, extra uintptr) (*SafeArray, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArrayCreateVector creates SafeArray.
+//
+// AKA: SafeArrayCreateVector in Windows API.
+func safeArrayCreateVector(variantType VT, lowerBound int32, length uint32) (*SafeArray, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArrayCreateVectorEx creates SafeArray.
+//
+// AKA: SafeArrayCreateVectorEx in Windows API.
+func safeArrayCreateVectorEx(variantType VT, lowerBound int32, length uint32, extra uintptr) (*SafeArray, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArrayDestroy destroys SafeArray object.
+//
+// AKA: SafeArrayDestroy in Windows API.
+func safeArrayDestroy(safearray *SafeArray) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayDestroyData destroys SafeArray object.
+//
+// AKA: SafeArrayDestroyData in Windows API.
+func safeArrayDestroyData(safearray *SafeArray) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayDestroyDescriptor destroys SafeArray object.
+//
+// AKA: SafeArrayDestroyDescriptor in Windows API.
+func safeArrayDestroyDescriptor(safearray *SafeArray) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayGetDim is the amount of dimensions in the SafeArray.
+//
+// SafeArrays may have multiple dimensions. Meaning, it could be
+// multidimensional array.
+//
+// AKA: SafeArrayGetDim in Windows API.
+func safeArrayGetDim(safearray *SafeArray) (*uint32, error) {
+	u := uint32(0)
+	return &u, NewError(E_NOTIMPL)
+}
+
+// safeArrayGetElementSize is the element size in bytes.
+//
+// AKA: SafeArrayGetElemsize in Windows API.
+func safeArrayGetElementSize(safearray *SafeArray) (*uint32, error) {
+	u := uint32(0)
+	return &u, NewError(E_NOTIMPL)
+}
+
+// safeArrayGetElement retrieves element at given index.
+func safeArrayGetElement(safearray *SafeArray, index int64, pv unsafe.Pointer) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayGetElement retrieves element at given index and converts to string.
+func safeArrayGetElementString(safearray *SafeArray, index int64) (string, error) {
+	return "", NewError(E_NOTIMPL)
+}
+
+// safeArrayGetIID is the InterfaceID of the elements in the SafeArray.
+//
+// AKA: SafeArrayGetIID in Windows API.
+func safeArrayGetIID(safearray *SafeArray) (*GUID, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArrayGetLBound returns lower bounds of SafeArray.
+//
+// SafeArrays may have multiple dimensions. Meaning, it could be
+// multidimensional array.
+//
+// AKA: SafeArrayGetLBound in Windows API.
+func safeArrayGetLBound(safearray *SafeArray, dimension uint32) (int64, error) {
+	return int64(0), NewError(E_NOTIMPL)
+}
+
+// safeArrayGetUBound returns upper bounds of SafeArray.
+//
+// SafeArrays may have multiple dimensions. Meaning, it could be
+// multidimensional array.
+//
+// AKA: SafeArrayGetUBound in Windows API.
+func safeArrayGetUBound(safearray *SafeArray, dimension uint32) (int64, error) {
+	return int64(0), NewError(E_NOTIMPL)
+}
+
+// safeArrayGetVartype returns data type of SafeArray.
+//
+// AKA: SafeArrayGetVartype in Windows API.
+func safeArrayGetVartype(safearray *SafeArray) (uint16, error) {
+	return uint16(0), NewError(E_NOTIMPL)
+}
+
+// safeArrayLock locks SafeArray for reading to modify SafeArray.
+//
+// This must be called during some calls to ensure that another process does not
+// read or write to the SafeArray during editing.
+//
+// AKA: SafeArrayLock in Windows API.
+func safeArrayLock(safearray *SafeArray) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayUnlock unlocks SafeArray for reading.
+//
+// AKA: SafeArrayUnlock in Windows API.
+func safeArrayUnlock(safearray *SafeArray) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayPutElement stores the data element at the specified location in the
+// array.
+//
+// AKA: SafeArrayPutElement in Windows API.
+func safeArrayPutElement(safearray *SafeArray, index int64, element uintptr) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayGetRecordInfo accesses IRecordInfo info for custom types.
+//
+// AKA: SafeArrayGetRecordInfo in Windows API.
+//
+// XXX: Must implement IRecordInfo interface for this to return.
+func safeArrayGetRecordInfo(safearray *SafeArray) (interface{}, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArraySetRecordInfo mutates IRecordInfo info for custom types.
+//
+// AKA: SafeArraySetRecordInfo in Windows API.
+//
+// XXX: Must implement IRecordInfo interface for this to return.
+func safeArraySetRecordInfo(safearray *SafeArray, recordInfo interface{}) error {
+	return NewError(E_NOTIMPL)
+}

vendor/github.com/go-ole/go-ole/safearray_windows.go

@@ -0,0 +1,337 @@
+// +build windows
+
+package ole
+
+import (
+	"unsafe"
+)
+
+var (
+	procSafeArrayAccessData, _        = modoleaut32.FindProc("SafeArrayAccessData")
+	procSafeArrayAllocData, _         = modoleaut32.FindProc("SafeArrayAllocData")
+	procSafeArrayAllocDescriptor, _   = modoleaut32.FindProc("SafeArrayAllocDescriptor")
+	procSafeArrayAllocDescriptorEx, _ = modoleaut32.FindProc("SafeArrayAllocDescriptorEx")
+	procSafeArrayCopy, _              = modoleaut32.FindProc("SafeArrayCopy")
+	procSafeArrayCopyData, _          = modoleaut32.FindProc("SafeArrayCopyData")
+	procSafeArrayCreate, _            = modoleaut32.FindProc("SafeArrayCreate")
+	procSafeArrayCreateEx, _          = modoleaut32.FindProc("SafeArrayCreateEx")
+	procSafeArrayCreateVector, _      = modoleaut32.FindProc("SafeArrayCreateVector")
+	procSafeArrayCreateVectorEx, _    = modoleaut32.FindProc("SafeArrayCreateVectorEx")
+	procSafeArrayDestroy, _           = modoleaut32.FindProc("SafeArrayDestroy")
+	procSafeArrayDestroyData, _       = modoleaut32.FindProc("SafeArrayDestroyData")
+	procSafeArrayDestroyDescriptor, _ = modoleaut32.FindProc("SafeArrayDestroyDescriptor")
+	procSafeArrayGetDim, _            = modoleaut32.FindProc("SafeArrayGetDim")
+	procSafeArrayGetElement, _        = modoleaut32.FindProc("SafeArrayGetElement")
+	procSafeArrayGetElemsize, _       = modoleaut32.FindProc("SafeArrayGetElemsize")
+	procSafeArrayGetIID, _            = modoleaut32.FindProc("SafeArrayGetIID")
+	procSafeArrayGetLBound, _         = modoleaut32.FindProc("SafeArrayGetLBound")
+	procSafeArrayGetUBound, _         = modoleaut32.FindProc("SafeArrayGetUBound")
+	procSafeArrayGetVartype, _        = modoleaut32.FindProc("SafeArrayGetVartype")
+	procSafeArrayLock, _              = modoleaut32.FindProc("SafeArrayLock")
+	procSafeArrayPtrOfIndex, _        = modoleaut32.FindProc("SafeArrayPtrOfIndex")
+	procSafeArrayUnaccessData, _      = modoleaut32.FindProc("SafeArrayUnaccessData")
+	procSafeArrayUnlock, _            = modoleaut32.FindProc("SafeArrayUnlock")
+	procSafeArrayPutElement, _        = modoleaut32.FindProc("SafeArrayPutElement")
+	//procSafeArrayRedim, _             = modoleaut32.FindProc("SafeArrayRedim") // TODO
+	//procSafeArraySetIID, _            = modoleaut32.FindProc("SafeArraySetIID") // TODO
+	procSafeArrayGetRecordInfo, _ = modoleaut32.FindProc("SafeArrayGetRecordInfo")
+	procSafeArraySetRecordInfo, _ = modoleaut32.FindProc("SafeArraySetRecordInfo")
+)
+
+// safeArrayAccessData returns raw array pointer.
+//
+// AKA: SafeArrayAccessData in Windows API.
+// Todo: Test
+func safeArrayAccessData(safearray *SafeArray) (element uintptr, err error) {
+	err = convertHresultToError(
+		procSafeArrayAccessData.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(unsafe.Pointer(&element))))
+	return
+}
+
+// safeArrayUnaccessData releases raw array.
+//
+// AKA: SafeArrayUnaccessData in Windows API.
+func safeArrayUnaccessData(safearray *SafeArray) (err error) {
+	err = convertHresultToError(procSafeArrayUnaccessData.Call(uintptr(unsafe.Pointer(safearray))))
+	return
+}
+
+// safeArrayAllocData allocates SafeArray.
+//
+// AKA: SafeArrayAllocData in Windows API.
+func safeArrayAllocData(safearray *SafeArray) (err error) {
+	err = convertHresultToError(procSafeArrayAllocData.Call(uintptr(unsafe.Pointer(safearray))))
+	return
+}
+
+// safeArrayAllocDescriptor allocates SafeArray.
+//
+// AKA: SafeArrayAllocDescriptor in Windows API.
+func safeArrayAllocDescriptor(dimensions uint32) (safearray *SafeArray, err error) {
+	err = convertHresultToError(
+		procSafeArrayAllocDescriptor.Call(uintptr(dimensions), uintptr(unsafe.Pointer(&safearray))))
+	return
+}
+
+// safeArrayAllocDescriptorEx allocates SafeArray.
+//
+// AKA: SafeArrayAllocDescriptorEx in Windows API.
+func safeArrayAllocDescriptorEx(variantType VT, dimensions uint32) (safearray *SafeArray, err error) {
+	err = convertHresultToError(
+		procSafeArrayAllocDescriptorEx.Call(
+			uintptr(variantType),
+			uintptr(dimensions),
+			uintptr(unsafe.Pointer(&safearray))))
+	return
+}
+
+// safeArrayCopy returns copy of SafeArray.
+//
+// AKA: SafeArrayCopy in Windows API.
+func safeArrayCopy(original *SafeArray) (safearray *SafeArray, err error) {
+	err = convertHresultToError(
+		procSafeArrayCopy.Call(
+			uintptr(unsafe.Pointer(original)),
+			uintptr(unsafe.Pointer(&safearray))))
+	return
+}
+
+// safeArrayCopyData duplicates SafeArray into another SafeArray object.
+//
+// AKA: SafeArrayCopyData in Windows API.
+func safeArrayCopyData(original *SafeArray, duplicate *SafeArray) (err error) {
+	err = convertHresultToError(
+		procSafeArrayCopyData.Call(
+			uintptr(unsafe.Pointer(original)),
+			uintptr(unsafe.Pointer(duplicate))))
+	return
+}
+
+// safeArrayCreate creates SafeArray.
+//
+// AKA: SafeArrayCreate in Windows API.
+func safeArrayCreate(variantType VT, dimensions uint32, bounds *SafeArrayBound) (safearray *SafeArray, err error) {
+	sa, _, err := procSafeArrayCreate.Call(
+		uintptr(variantType),
+		uintptr(dimensions),
+		uintptr(unsafe.Pointer(bounds)))
+	safearray = (*SafeArray)(unsafe.Pointer(&sa))
+	return
+}
+
+// safeArrayCreateEx creates SafeArray.
+//
+// AKA: SafeArrayCreateEx in Windows API.
+func safeArrayCreateEx(variantType VT, dimensions uint32, bounds *SafeArrayBound, extra uintptr) (safearray *SafeArray, err error) {
+	sa, _, err := procSafeArrayCreateEx.Call(
+		uintptr(variantType),
+		uintptr(dimensions),
+		uintptr(unsafe.Pointer(bounds)),
+		extra)
+	safearray = (*SafeArray)(unsafe.Pointer(sa))
+	return
+}
+
+// safeArrayCreateVector creates SafeArray.
+//
+// AKA: SafeArrayCreateVector in Windows API.
+func safeArrayCreateVector(variantType VT, lowerBound int32, length uint32) (safearray *SafeArray, err error) {
+	sa, _, err := procSafeArrayCreateVector.Call(
+		uintptr(variantType),
+		uintptr(lowerBound),
+		uintptr(length))
+	safearray = (*SafeArray)(unsafe.Pointer(sa))
+	return
+}
+
+// safeArrayCreateVectorEx creates SafeArray.
+//
+// AKA: SafeArrayCreateVectorEx in Windows API.
+func safeArrayCreateVectorEx(variantType VT, lowerBound int32, length uint32, extra uintptr) (safearray *SafeArray, err error) {
+	sa, _, err := procSafeArrayCreateVectorEx.Call(
+		uintptr(variantType),
+		uintptr(lowerBound),
+		uintptr(length),
+		extra)
+	safearray = (*SafeArray)(unsafe.Pointer(sa))
+	return
+}
+
+// safeArrayDestroy destroys SafeArray object.
+//
+// AKA: SafeArrayDestroy in Windows API.
+func safeArrayDestroy(safearray *SafeArray) (err error) {
+	err = convertHresultToError(procSafeArrayDestroy.Call(uintptr(unsafe.Pointer(safearray))))
+	return
+}
+
+// safeArrayDestroyData destroys SafeArray object.
+//
+// AKA: SafeArrayDestroyData in Windows API.
+func safeArrayDestroyData(safearray *SafeArray) (err error) {
+	err = convertHresultToError(procSafeArrayDestroyData.Call(uintptr(unsafe.Pointer(safearray))))
+	return
+}
+
+// safeArrayDestroyDescriptor destroys SafeArray object.
+//
+// AKA: SafeArrayDestroyDescriptor in Windows API.
+func safeArrayDestroyDescriptor(safearray *SafeArray) (err error) {
+	err = convertHresultToError(procSafeArrayDestroyDescriptor.Call(uintptr(unsafe.Pointer(safearray))))
+	return
+}
+
+// safeArrayGetDim is the amount of dimensions in the SafeArray.
+//
+// SafeArrays may have multiple dimensions. Meaning, it could be
+// multidimensional array.
+//
+// AKA: SafeArrayGetDim in Windows API.
+func safeArrayGetDim(safearray *SafeArray) (dimensions *uint32, err error) {
+	l, _, err := procSafeArrayGetDim.Call(uintptr(unsafe.Pointer(safearray)))
+	dimensions = (*uint32)(unsafe.Pointer(l))
+	return
+}
+
+// safeArrayGetElementSize is the element size in bytes.
+//
+// AKA: SafeArrayGetElemsize in Windows API.
+func safeArrayGetElementSize(safearray *SafeArray) (length *uint32, err error) {
+	l, _, err := procSafeArrayGetElemsize.Call(uintptr(unsafe.Pointer(safearray)))
+	length = (*uint32)(unsafe.Pointer(l))
+	return
+}
+
+// safeArrayGetElement retrieves element at given index.
+func safeArrayGetElement(safearray *SafeArray, index int64, pv unsafe.Pointer) error {
+	return convertHresultToError(
+		procSafeArrayGetElement.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(unsafe.Pointer(&index)),
+			uintptr(pv)))
+}
+
+// safeArrayGetElementString retrieves element at given index and converts to string.
+func safeArrayGetElementString(safearray *SafeArray, index int64) (str string, err error) {
+	var element *int16
+	err = convertHresultToError(
+		procSafeArrayGetElement.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(unsafe.Pointer(&index)),
+			uintptr(unsafe.Pointer(&element))))
+	str = BstrToString(*(**uint16)(unsafe.Pointer(&element)))
+	SysFreeString(element)
+	return
+}
+
+// safeArrayGetIID is the InterfaceID of the elements in the SafeArray.
+//
+// AKA: SafeArrayGetIID in Windows API.
+func safeArrayGetIID(safearray *SafeArray) (guid *GUID, err error) {
+	err = convertHresultToError(
+		procSafeArrayGetIID.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(unsafe.Pointer(&guid))))
+	return
+}
+
+// safeArrayGetLBound returns lower bounds of SafeArray.
+//
+// SafeArrays may have multiple dimensions. Meaning, it could be
+// multidimensional array.
+//
+// AKA: SafeArrayGetLBound in Windows API.
+func safeArrayGetLBound(safearray *SafeArray, dimension uint32) (lowerBound int64, err error) {
+	err = convertHresultToError(
+		procSafeArrayGetLBound.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(dimension),
+			uintptr(unsafe.Pointer(&lowerBound))))
+	return
+}
+
+// safeArrayGetUBound returns upper bounds of SafeArray.
+//
+// SafeArrays may have multiple dimensions. Meaning, it could be
+// multidimensional array.
+//
+// AKA: SafeArrayGetUBound in Windows API.
+func safeArrayGetUBound(safearray *SafeArray, dimension uint32) (upperBound int64, err error) {
+	err = convertHresultToError(
+		procSafeArrayGetUBound.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(dimension),
+			uintptr(unsafe.Pointer(&upperBound))))
+	return
+}
+
+// safeArrayGetVartype returns data type of SafeArray.
+//
+// AKA: SafeArrayGetVartype in Windows API.
+func safeArrayGetVartype(safearray *SafeArray) (varType uint16, err error) {
+	err = convertHresultToError(
+		procSafeArrayGetVartype.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(unsafe.Pointer(&varType))))
+	return
+}
+
+// safeArrayLock locks SafeArray for reading to modify SafeArray.
+//
+// This must be called during some calls to ensure that another process does not
+// read or write to the SafeArray during editing.
+//
+// AKA: SafeArrayLock in Windows API.
+func safeArrayLock(safearray *SafeArray) (err error) {
+	err = convertHresultToError(procSafeArrayLock.Call(uintptr(unsafe.Pointer(safearray))))
+	return
+}
+
+// safeArrayUnlock unlocks SafeArray for reading.
+//
+// AKA: SafeArrayUnlock in Windows API.
+func safeArrayUnlock(safearray *SafeArray) (err error) {
+	err = convertHresultToError(procSafeArrayUnlock.Call(uintptr(unsafe.Pointer(safearray))))
+	return
+}
+
+// safeArrayPutElement stores the data element at the specified location in the
+// array.
+//
+// AKA: SafeArrayPutElement in Windows API.
+func safeArrayPutElement(safearray *SafeArray, index int64, element uintptr) (err error) {
+	err = convertHresultToError(
+		procSafeArrayPutElement.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(unsafe.Pointer(&index)),
+			uintptr(unsafe.Pointer(element))))
+	return
+}
+
+// safeArrayGetRecordInfo accesses IRecordInfo info for custom types.
+//
+// AKA: SafeArrayGetRecordInfo in Windows API.
+//
+// XXX: Must implement IRecordInfo interface for this to return.
+func safeArrayGetRecordInfo(safearray *SafeArray) (recordInfo interface{}, err error) {
+	err = convertHresultToError(
+		procSafeArrayGetRecordInfo.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(unsafe.Pointer(&recordInfo))))
+	return
+}
+
+// safeArraySetRecordInfo mutates IRecordInfo info for custom types.
+//
+// AKA: SafeArraySetRecordInfo in Windows API.
+//
+// XXX: Must implement IRecordInfo interface for this to return.
+func safeArraySetRecordInfo(safearray *SafeArray, recordInfo interface{}) (err error) {
+	err = convertHresultToError(
+		procSafeArraySetRecordInfo.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(unsafe.Pointer(&recordInfo))))
+	return
+}

vendor/github.com/go-ole/go-ole/safearrayconversion.go

@@ -0,0 +1,140 @@
+// Helper for converting SafeArray to array of objects.
+
+package ole
+
+import (
+	"unsafe"
+)
+
+type SafeArrayConversion struct {
+	Array *SafeArray
+}
+
+func (sac *SafeArrayConversion) ToStringArray() (strings []string) {
+	totalElements, _ := sac.TotalElements(0)
+	strings = make([]string, totalElements)
+
+	for i := int64(0); i < totalElements; i++ {
+		strings[int32(i)], _ = safeArrayGetElementString(sac.Array, i)
+	}
+
+	return
+}
+
+func (sac *SafeArrayConversion) ToByteArray() (bytes []byte) {
+	totalElements, _ := sac.TotalElements(0)
+	bytes = make([]byte, totalElements)
+
+	for i := int64(0); i < totalElements; i++ {
+		safeArrayGetElement(sac.Array, i, unsafe.Pointer(&bytes[int32(i)]))
+	}
+
+	return
+}
+
+func (sac *SafeArrayConversion) ToValueArray() (values []interface{}) {
+	totalElements, _ := sac.TotalElements(0)
+	values = make([]interface{}, totalElements)
+	vt, _ := safeArrayGetVartype(sac.Array)
+
+	for i := 0; i < int(totalElements); i++ {
+		switch VT(vt) {
+		case VT_BOOL:
+			var v bool
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v
+		case VT_I1:
+			var v int8
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v
+		case VT_I2:
+			var v int16
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v
+		case VT_I4:
+			var v int32
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v
+		case VT_I8:
+			var v int64
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v
+		case VT_UI1:
+			var v uint8
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v
+		case VT_UI2:
+			var v uint16
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v
+		case VT_UI4:
+			var v uint32
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v
+		case VT_UI8:
+			var v uint64
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v
+		case VT_R4:
+			var v float32
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v
+		case VT_R8:
+			var v float64
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v
+		case VT_BSTR:
+			var v string
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v
+		case VT_VARIANT:
+			var v VARIANT
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v.Value()
+		default:
+			// TODO
+		}
+	}
+
+	return
+}
+
+func (sac *SafeArrayConversion) GetType() (varType uint16, err error) {
+	return safeArrayGetVartype(sac.Array)
+}
+
+func (sac *SafeArrayConversion) GetDimensions() (dimensions *uint32, err error) {
+	return safeArrayGetDim(sac.Array)
+}
+
+func (sac *SafeArrayConversion) GetSize() (length *uint32, err error) {
+	return safeArrayGetElementSize(sac.Array)
+}
+
+func (sac *SafeArrayConversion) TotalElements(index uint32) (totalElements int64, err error) {
+	if index < 1 {
+		index = 1
+	}
+
+	// Get array bounds
+	var LowerBounds int64
+	var UpperBounds int64
+
+	LowerBounds, err = safeArrayGetLBound(sac.Array, index)
+	if err != nil {
+		return
+	}
+
+	UpperBounds, err = safeArrayGetUBound(sac.Array, index)
+	if err != nil {
+		return
+	}
+
+	totalElements = UpperBounds - LowerBounds + 1
+	return
+}
+
+// Release Safe Array memory
+func (sac *SafeArrayConversion) Release() {
+	safeArrayDestroy(sac.Array)
+}

vendor/github.com/go-ole/go-ole/safearrayslices.go

@@ -0,0 +1,33 @@
+// +build windows
+
+package ole
+
+import (
+	"unsafe"
+)
+
+func safeArrayFromByteSlice(slice []byte) *SafeArray {
+	array, _ := safeArrayCreateVector(VT_UI1, 0, uint32(len(slice)))
+
+	if array == nil {
+		panic("Could not convert []byte to SAFEARRAY")
+	}
+
+	for i, v := range slice {
+		safeArrayPutElement(array, int64(i), uintptr(unsafe.Pointer(&v)))
+	}
+	return array
+}
+
+func safeArrayFromStringSlice(slice []string) *SafeArray {
+	array, _ := safeArrayCreateVector(VT_BSTR, 0, uint32(len(slice)))
+
+	if array == nil {
+		panic("Could not convert []string to SAFEARRAY")
+	}
+	// SysAllocStringLen(s)
+	for i, v := range slice {
+		safeArrayPutElement(array, int64(i), uintptr(unsafe.Pointer(SysAllocStringLen(v))))
+	}
+	return array
+}

vendor/github.com/go-ole/go-ole/utility.go

@@ -0,0 +1,101 @@
+package ole
+
+import (
+	"unicode/utf16"
+	"unsafe"
+)
+
+// ClassIDFrom retrieves class ID whether given is program ID or application string.
+//
+// Helper that provides check against both Class ID from Program ID and Class ID from string. It is
+// faster, if you know which you are using, to use the individual functions, but this will check
+// against available functions for you.
+func ClassIDFrom(programID string) (classID *GUID, err error) {
+	classID, err = CLSIDFromProgID(programID)
+	if err != nil {
+		classID, err = CLSIDFromString(programID)
+		if err != nil {
+			return
+		}
+	}
+	return
+}
+
+// BytePtrToString converts byte pointer to a Go string.
+func BytePtrToString(p *byte) string {
+	a := (*[10000]uint8)(unsafe.Pointer(p))
+	i := 0
+	for a[i] != 0 {
+		i++
+	}
+	return string(a[:i])
+}
+
+// UTF16PtrToString is alias for LpOleStrToString.
+//
+// Kept for compatibility reasons.
+func UTF16PtrToString(p *uint16) string {
+	return LpOleStrToString(p)
+}
+
+// LpOleStrToString converts COM Unicode to Go string.
+func LpOleStrToString(p *uint16) string {
+	if p == nil {
+		return ""
+	}
+
+	length := lpOleStrLen(p)
+	a := make([]uint16, length)
+
+	ptr := unsafe.Pointer(p)
+
+	for i := 0; i < int(length); i++ {
+		a[i] = *(*uint16)(ptr)
+		ptr = unsafe.Pointer(uintptr(ptr) + 2)
+	}
+
+	return string(utf16.Decode(a))
+}
+
+// BstrToString converts COM binary string to Go string.
+func BstrToString(p *uint16) string {
+	if p == nil {
+		return ""
+	}
+	length := SysStringLen((*int16)(unsafe.Pointer(p)))
+	a := make([]uint16, length)
+
+	ptr := unsafe.Pointer(p)
+
+	for i := 0; i < int(length); i++ {
+		a[i] = *(*uint16)(ptr)
+		ptr = unsafe.Pointer(uintptr(ptr) + 2)
+	}
+	return string(utf16.Decode(a))
+}
+
+// lpOleStrLen returns the length of Unicode string.
+func lpOleStrLen(p *uint16) (length int64) {
+	if p == nil {
+		return 0
+	}
+
+	ptr := unsafe.Pointer(p)
+
+	for i := 0; ; i++ {
+		if 0 == *(*uint16)(ptr) {
+			length = int64(i)
+			break
+		}
+		ptr = unsafe.Pointer(uintptr(ptr) + 2)
+	}
+	return
+}
+
+// convertHresultToError converts syscall to error, if call is unsuccessful.
+func convertHresultToError(hr uintptr, r2 uintptr, ignore error) (err error) {
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}

vendor/github.com/go-ole/go-ole/variables.go

@@ -0,0 +1,16 @@
+// +build windows
+
+package ole
+
+import (
+	"syscall"
+)
+
+var (
+	modcombase     = syscall.NewLazyDLL("combase.dll")
+	modkernel32, _ = syscall.LoadDLL("kernel32.dll")
+	modole32, _    = syscall.LoadDLL("ole32.dll")
+	modoleaut32, _ = syscall.LoadDLL("oleaut32.dll")
+	modmsvcrt, _   = syscall.LoadDLL("msvcrt.dll")
+	moduser32, _   = syscall.LoadDLL("user32.dll")
+)

vendor/github.com/go-ole/go-ole/variant.go

@@ -0,0 +1,105 @@
+package ole
+
+import "unsafe"
+
+// NewVariant returns new variant based on type and value.
+func NewVariant(vt VT, val int64) VARIANT {
+	return VARIANT{VT: vt, Val: val}
+}
+
+// ToIUnknown converts Variant to Unknown object.
+func (v *VARIANT) ToIUnknown() *IUnknown {
+	if v.VT != VT_UNKNOWN {
+		return nil
+	}
+	return (*IUnknown)(unsafe.Pointer(uintptr(v.Val)))
+}
+
+// ToIDispatch converts variant to dispatch object.
+func (v *VARIANT) ToIDispatch() *IDispatch {
+	if v.VT != VT_DISPATCH {
+		return nil
+	}
+	return (*IDispatch)(unsafe.Pointer(uintptr(v.Val)))
+}
+
+// ToArray converts variant to SafeArray helper.
+func (v *VARIANT) ToArray() *SafeArrayConversion {
+	if v.VT != VT_SAFEARRAY {
+		if v.VT&VT_ARRAY == 0 {
+			return nil
+		}
+	}
+	var safeArray *SafeArray = (*SafeArray)(unsafe.Pointer(uintptr(v.Val)))
+	return &SafeArrayConversion{safeArray}
+}
+
+// ToString converts variant to Go string.
+func (v *VARIANT) ToString() string {
+	if v.VT != VT_BSTR {
+		return ""
+	}
+	return BstrToString(*(**uint16)(unsafe.Pointer(&v.Val)))
+}
+
+// Clear the memory of variant object.
+func (v *VARIANT) Clear() error {
+	return VariantClear(v)
+}
+
+// Value returns variant value based on its type.
+//
+// Currently supported types: 2- and 4-byte integers, strings, bools.
+// Note that 64-bit integers, datetimes, and other types are stored as strings
+// and will be returned as strings.
+//
+// Needs to be further converted, because this returns an interface{}.
+func (v *VARIANT) Value() interface{} {
+	switch v.VT {
+	case VT_I1:
+		return int8(v.Val)
+	case VT_UI1:
+		return uint8(v.Val)
+	case VT_I2:
+		return int16(v.Val)
+	case VT_UI2:
+		return uint16(v.Val)
+	case VT_I4:
+		return int32(v.Val)
+	case VT_UI4:
+		return uint32(v.Val)
+	case VT_I8:
+		return int64(v.Val)
+	case VT_UI8:
+		return uint64(v.Val)
+	case VT_INT:
+		return int(v.Val)
+	case VT_UINT:
+		return uint(v.Val)
+	case VT_INT_PTR:
+		return uintptr(v.Val) // TODO
+	case VT_UINT_PTR:
+		return uintptr(v.Val)
+	case VT_R4:
+		return *(*float32)(unsafe.Pointer(&v.Val))
+	case VT_R8:
+		return *(*float64)(unsafe.Pointer(&v.Val))
+	case VT_BSTR:
+		return v.ToString()
+	case VT_DATE:
+		// VT_DATE type will either return float64 or time.Time.
+		d := float64(v.Val)
+		date, err := GetVariantDate(d)
+		if err != nil {
+			return d
+		}
+		return date
+	case VT_UNKNOWN:
+		return v.ToIUnknown()
+	case VT_DISPATCH:
+		return v.ToIDispatch()
+	case VT_BOOL:
+		return v.Val != 0
+	}
+	return nil
+}

vendor/github.com/go-ole/go-ole/variant_386.go

@@ -0,0 +1,11 @@
+// +build 386
+
+package ole
+
+type VARIANT struct {
+	VT         VT     //  2
+	wReserved1 uint16 //  4
+	wReserved2 uint16 //  6
+	wReserved3 uint16 //  8
+	Val        int64  // 16
+}