Golang org x sys windows svc

Rendered for windows/amd64

import "golang.org/x/sys/windows/svc"

Package svc provides everything required to build Windows service.

Package Files
¶

event.go go13.go security.go service.go

Constants ¶

func IsAnInteractiveSession ¶

IsAnInteractiveSession determines if calling process is running interactively.
It queries the process token for membership in the Interactive group.
http://stackoverflow.com/questions/2668851/how-do-i-detect-that-my-application-is-running-as-service-or-in-an-interactive-s

func Run ¶

Run executes service name by calling appropriate handler function.

type Accepted ¶

Accepted is used to describe commands accepted by the service.
Note that Interrogate is always accepted.

type ChangeRequest ¶

type ChangeRequest struct {
    Cmd           Cmd
    CurrentStatus Status
}

ChangeRequest is sent to the service Handler to request service status change.

type Cmd ¶

Cmd represents service state change request. It is sent to a service
by the service manager, and should be actioned upon by the service.

type Handler ¶

type Handler interface {

    // Execute will be called by the package code at the start of
    // the service, and the service will exit once Execute completes.
    // Inside Execute you must read service change requests from r and
    // act accordingly. You must keep service control manager up to date
    // about state of your service by writing into s as required.
    // args contains service name followed by argument strings passed
    // to the service.
    // You can provide service exit code in exitCode return parameter,
    // with 0 being "no error". You can also indicate if exit code,
    // if any, is service specific or not by using svcSpecificEC
    // parameter.
    Execute(args []string, r <-chan ChangeRequest, s chan<- Status) (svcSpecificEC bool, exitCode uint32)
}

Handler is the interface that must be implemented to build Windows service.

type State ¶

State describes service execution state (Stopped, Running and so on).

type Status ¶

type Status struct {
    State      State
    Accepts    Accepted
    CheckPoint uint32 // used to report progress during a lengthy operation
    WaitHint   uint32 // estimated time required for a pending operation, in milliseconds
}

Status combines State and Accepted commands to fully describe running service.

Bugs ¶

☞ There is no mechanism to run multiple services
inside one single executable. Perhaps, it can be overcome by
using RegisterServiceCtrlHandlerEx Windows api.

Directories ¶

how to install gogs as windows service? #630

No description provided.

The text was updated successfully, but these errors were encountered:

I’ve received this feature request 10 times today. no built-in support yet, but found a way to deal with it: etcd-io/etcd#1628

haha, thanks, this feature is useful for cross platform

As a workaround I got this working with NSSM, as srvany is 32-bit only:
http://nssm.cc/

Run nssm install and you get a helpful GUI.

@jcracknell thanks your info! @chai2010 got a working solution for 64-bit too. I’ll add those info to FAQs.

@jcracknell @unknwon nssm is a perfect solution. thanks.

@unknwon
If gogs add the following import to one of the files

It won’t affect non-windows at all, but on windows allow installing directly as a windows service.
I could send a PR if you’re open to that.

Can you explain or give some references about how does this package actually work?

Windows requires services to maintain callbacks and respond to query messages and stop messages. The package minwinsvc works by:

Under the covers on windows it uses golang.org/x/sys/windows/svc which works on go1.3+.

Источник

Как я домашний Git-сервер Gogs на Alpine linux устанавливал

“Опасное это дело, Фродо, выходить за порог: стоит ступить на дорогу и, если дашь волю ногам, неизвестно куда тебя занесет.”

С чего всё началось

Мне захотелось завести себе домашний Git-сервер, чтобы практиковаться в разработке и развёртывании пет-проектов. Плюс спокойнее, когда твои наработки лежат не только на github.

В качестве операционной системы выбрал Alpine linux, так как меня заинтересовали её возможности. Был опыт размещения на ней небольшого сервиса. Понравилось, что в ней нет ничего лишнего, а ещё она очень лёгкая в плане системных ресурсов.

Исходные данные

Реализацию Git-сервера выбирал из числа открытых и бесплатных проектов. Решил взять для начала, тот у которого меньше настроек и лишних плюшек. Мне нужен git-сервер, который не требователен к ресурсам и наличием базовых операций. Остановился на проекте Gogs.io.

Причины такого выбора:

знакомый интерфейс, т.к. использую на работе;

минимальный набор настроек и функционала;

Мой гипервизор пока обладает скромным железом. В распоряжении только:

Из них 1-2 Гб ОЗУ забирает ОС гипервизора. Значит на контейнеры и виртуалки остаётся не так много ресурсов. Решил, что для 1-2 пользователей git-сервера хватит одного ядра, 512 Мб ОЗУ и 8 Гб диска.

Запуск контейнера с ОС Alpine

Настройка и запуск Alpine на Proxmox очень просты и удобны. Описывать их не буду. Скажу только, что мне эта тема с шаблонами очень понравилась. Жаль, что самих шаблонов не так много на мой взгляд.

С другой стороны, никто не мешает развернуть любую ОС и поставить нужный сервис из её пакетов. Например в Alpine так:

Подготовка системы

Сменил имя хоста сервера:

Вначале я установил openssh и nano для его настройки, чтобы нормально подключаться по ssh:

Далее добавил демон в автозагрузку:

Поправил конфиг /etc/ssh/sshd_config и убрал комментарии строк:

Всё, запустил демон:

Установка сервиса Gogs

Попытка первая

В документации к Alpine рекомендуют для разработки использовать Gitea. Но это слишком просто неть, поэтому выбрал другое. Я решил внаглую установить git-сервер командой:

В результате, система помимо самого сервиса gogs установила ещё и дополнительные пакеты, например сам git. Пробую запустить сервер и получаю ошибку:

Как мы видим, ему не хватает конфига и структуры каталогов для работы. Проверил каталог /usr/bin, там оказался лишь одинокий исполняемый файл gogs.

Попытка вторая

После первой попытки я попробовал воссоздать необходимую структуру и конфиг вручную. Ничего хорошего из этого не вышло.

Решил попробовать вот этот. Скопировал его в директорию /opt на Alpine:

Мой замысел был в том, что либо он заработает после распаковки сразу, либо с него можно будет взять недостающей структуры и конфигов. Поменял права на директорию распакованного gogs:

Попробовал запустить и получил странную ошибку (спойлер: не удивительно, ведь С-компиляторы разные на Alpine это mysl, но об этом я узнаю позже):

Тогда то мне и пришла дикая идея подсунуть gogs из Alpine пакетов:

И бинго! Сервер стартанул и я даже смог его настроить из веб-интерфейса. Но это был не конец…

Попытка третья

Несмотря на охватившую меня эйфорию, радости и “я у мамки сисадмин!” весь следующий день я провёл в раздумьях. Мне не верилось, что в таком перспективном проекте как Alpine, есть место битому пакету. Чувство, что ошибка на моей стороне, не давала покоя.

Я нашел телеграм-чат по Alpine и (увы) на ломаном инглише объяснил свою проблему. Меня направили проверять конфиги в репозитории пакета gogs проекта Alpine.

Дальше настраивал по этому видео-уроку, начиная с момента про настройку из веб-интерфейса.

Конечно, это не полная настройка. При настройке из GUI, я выяснил, что нужно ещё ставить bash.

Путём перебора вариантов пришёл к такому:

Как на самом деле нужно было

После такого долгого пути экспериментов и щупанья головой стены на прочность, меня осенило! Сервер не нужно запускать вручную, он должен стартовать вместе с системой. Значит, его надо настроить по аналогии с openssh.

Этого действительно достаточно, чтобы запустить свой Git-сервер (если вас устраивает БД SQLite). Теперь можно идти на веб-интерфейс, у меня это был http://192.168.50.205:3000, и делать базовые настройки.

Заключение

Этой статьёй я хочу обратить внимание на важность документации и навыков по ОС Linux. Скорее всего, опытные линуксоиды сразу поняли в чём дело и от души посмеялись над моим дилетанством. Что ж, теперь мне и самому забавно, каким извилистым был мой путь =).

Но правда также и в том, что простой справки по развороту именно пакета gogs на Alpine я не нашёл. Надеюсь, моя статья будет полезна тем, кто задумает нечто подобное.

Источник

Gogs: легковесный git-сервис

В числе самых обсуждаемых последних новостей в сообществе разработчиков были новые тарифы GitHub (см., например, здесь).

Конечно, у новых тарифов есть свои преимущества, но с нынешним курсом доллара их вряд ли можно назвать выгодными для российских пользователей.

Некоторые прибегают к альтернативному решению и разворачивают GitLab (или другой git-сервис) на собственном или арендованном сервере.

Но и у этого решения есть свои подводные камни: GitLab очень требователен к системным ресурсам. Для частных лиц гораздо проще платить 7 долларов в месяц за GitHub, чем арендовать сервер надлежащей конфигурации.

Из сказанного, однако, не следует, что у GitHub на сегодняшний день альтернативы нет. Об одном весьма интересном и перспективном решении мы хотели бы рассказать в этой статье. Знакомьтесь: Gogs. Этот инструмент будет интересен как для индивидуальных разработчиков, так и для небольших компаний.

Общая информация

Gogs — продукт китайских разработчиков. На первый взгляд он почти ничем не отличается от GitHub или BitBucket — это даже по дизайну заметно.
Но при всех внешних сходствах у него есть одно выгодное отличие от существующих аналогов: легковесность.

Gogs написан на Go (собственно, это название представляет собой сокращение от Go Git Service). Из этого факта вытекают серьёзные преимущества: низкие требования к системным ресурсам, минимум зависимостей, простота установки и настройки.

Продвижение Gogs на международном рынке началось в конце 2014 — начале 2015 года. Весной 2015 года появились первые статьи о нём на западных сайтах, что также способствовало популяризации продукта. Но говорить о полноценной конкуренции с GitHub и GitLab было ещё рано: у Gogs даже поддержки пулл-реквестов не было, не говоря уже о других важных функциях.

В конце 2015 года после более чем полугодового перерыва вышла в свет новая версия продукта. В ней было реализовано множество нововведений, самыми важными из которых являются, конечно же, поддержка пулл-реквестов и возможность создания вики-страниц для проектов.
Дизайн Gogs также был заметно улучшен, а интерфейс перевели на 18 языков, включая русский.

Gogs, GitHub и GitLab

Сравним Gogs с другими инструментами аналогичного плана. Результаты сравнения для наглядности представим в виде таблицы:

Установка Gogs

Рассмотрим процедуру установки и первичной настройки на примере OC Ubuntu 16.04. В качестве СУБД возьмем привычный MySQL.

После этого создайте файл gogs.sql:

Добавьте в него следующие строки:

Сохраните внесённые изменения и выполните:

Чтобы уcтановить gogs из исходников, вам понадобятся также системы контроля версий git и mercurial:

Далее вам нужно будет установить компилятор Go. Откройте файл /.bashrc и добавьте в него следующие строки:

Сохраните изменения и выполните:

После этого установить компилятор Go:

Все необходимые зависимости установлены. Можно устанавливать Gogs:

По завершении установки нужно настроить запуск Gogs как службы. Для этого вам потребуется просто добавить в /etc/system/systemd файл gogs.service (шаблон см. здесь) и выполнить после этого следующие команды:.

Если всё сделано правильно, то по завершении установки страница настройки Gogs будет доступна по адресу http:// [IP-адрес сервера]:3000. Вся дальнейшая настройка осуществляется через графический интерфейс; там всё довольно просто и интуитивно понятно. Если вы планируете привязать к серверу с Gogs домен, вам потребуется также установить Nginx и настроить его в качестве обратного прокси (подробнее в официальной документации).

В процедуре установки Gogs ничего сложного нет. Но если вы являетесь пользователем нашего сервиса Vscale (кстати, отличный повод им стать), то всё можно сделать ещё проще: совсем недавно мы добавили в панель управления соответствующий образ. Один клик ― и виртуальная машина с уже установленным и настроенным Gogs создана и готова к использованию:

Как только сервер будет создан, откройте в браузере страницу http://[IP-адрес сервера]. Ничего настраивать дополнительно вам не потребуется: всё уже прописано в шаблоне и готово к работе.
Войдите в Gogs с помощью логина и пароля, полученных при установке.

Gogs в работе

Работать с Gogs просто. Если у вас есть опыт работы с GitHub, то вы без труда во всём разберётесь. Для начинающих пользователей в панели управления приводятся подробные шпаргалки.
Приведём элементраный пример. Создадим через графический интерфейс тестовый репозиторий.
После этого клонируем его на локальную машину:

Внесём небольшие изменения в файл README.md:

Закоммитим внесённые изменения:

Вам будет предложено ввести логин и пароль пользователя Gogs. После этого коммит будет добавлен в репозиторий. В панели управления всё это выглядит так:

Заключение

Мы попробовали поработать с Gogs – и остались вполне довольны. У продукта китайских разработчиков перспективы есть, и неплохие. За последний год (а в первый раз мы познакомились с Gogs в начале 2015 года) была проделана огромная работа по его усовершенствованию, и мы надеемся, что она будет продолжена в будущем.

Gogs уже сейчас является вполне достойной альтернативой GitHub и GitLab.В плане потребления системных ресурсов он гораздо экономичнее, чем любое из аналогичных решений. Как утверждают разработчики в своём блоге, его можно установить даже на RaspberryPi. Не знаем, как насчёт RaspberryPi, но на виртуальном сервере самой простой конфигурации в Vscale Gogs работает вполне стабильно на небольшом количестве репозиториев. Приглашаем всех попробовать и оценить. Если у вас уже есть опыт работы с Gogs — будем рады, если вы поделитесь им в комментариях.

Специально для тех, кто хочет получить готовый настроенный git-сервис, но при этом предпочитает более традиционные и уже зарекомендовавшие себя решения, мы добавили образ с GitLab. Сразу же отметим, что для самых бюджетных и популярных тарифов он недоступен: GitLab потребляет слишком много системных ресурсов, и серверы “младших” конфигураций его просто-напросто не потянут.

Источник

Установка Gogs в Ubuntu 14.04

Gogs – это самодостаточный сервис Git (англ. self-hosted Git service), написанный на Go; он очень прост в установке и потребляет мало системных ресурсов. На сегодня он считается самым простым и быстрым способом создать самодостаточный сервис Git.

Выполнив это руководство, вы получите готовую к работе установку Gogs, которая включает в себя веб-интерфейс, панель инструментов администратора и доступ к общим операциям Git (например, pull и push).

Требования

Чтобы следовать руководству, понадобятся:

1: Установка базы данных

Сначала нужно создать бэк-энд базу данных для Gogs.

Обновите пакеты системы:

sudo apt-get update

Во время установки программа запросит root-пароль MySQL. Выберите надёжный пароль и запомните его – он пригодится в дальнейшем.

Теперь создайте и откройте файл по имени gogs.sql. Для этого используйте любой удобный текстовый редактор (в данном руководстве это nano).

В этот файл внесите следующий код, а затем сохраните и закройте файл:

DROP DATABASE IF EXISTS gogs;
CREATE DATABASE IF NOT EXISTS gogs CHARACTER SET utf8 COLLATE utf8_general_ci;

Затем выполните файл gogs.sql, чтобы создать базу данных Gogs. Замените your_password только что установленным root-паролем mysql.

Для установки Gogs из исходного кода понадобятся инструменты управления версиями Git и Mercurial. ЧТобы установить эти инструменты, используйте:

Чтобы клонировать репозиторий по SSH, понадобится функционирующий SSH-сервер; к счастью, Ubuntu 14.04 поставляется с таким сервером “из коробки”.

2: Установка Go

Теперь нужно установить Go, поскольку сервис Gogs написан на этом языке.

Для начала установите некоторые переменные среды. Откройте файл

/.bashrc для редактирования.

В конец файла внесите следующие строки, а затем сохраните и закройте его:

export GOPATH=/home/git/go
export GOROOT=/usr/local/src/go
export PATH=$:$GOROOT/bin

Чтобы применить изменения, используйте:

Затем загрузите последнюю версию Go с сайта проекта при помощи команды wget. На момент написания руководства последней версией является go1.4.2.linux-amd64.tar.gz.

Чтобы разархивировать пакет, используйте tar:

tar zxf go1.4.2.linux-amd64.tar.gz

Если теперь ввести в терминал:

Появится примерно такой вывод:

3: Установка Gogs

Go имеет встроенную команду get, которая позволяет быстро скачать исходный код проектов Go со всеми зависимостями; используйте эту команду для загрузки Gogs:

Затем соберите и сгенерируйте бинарные файлы. Запуск этой команды может занять некоторое время:

Для управления сервисом Gogs используйте Supervisor. Чтобы установить Supervisor:

Теперь создайте демон Gogs путём создания раздела настроек Supervisor. Для начала создайте каталог для хранения лог-файлов:

Затем откройте конфигурационный файл Supervisor для редактирования.

sudo nano /etc/supervisor/supervisord.conf

Внесите в файл следующий код, чтобы создать раздел настроек для Gogs:

[program:gogs] directory=/home/git/go/src/github.com/gogits/gogs/
command=/home/git/go/src/github.com/gogits/gogs/gogs web
autostart=true
autorestart=true
startsecs=10
stdout_logfile=/var/log/gogs/stdout.log
stdout_logfile_maxbytes=1MB
stdout_logfile_backups=10
stdout_capture_maxbytes=1MB
stderr_logfile=/var/log/gogs/stderr.log
stderr_logfile_maxbytes=1MB
stderr_logfile_backups=10
stderr_capture_maxbytes=1MB
environment = HOME=»/home/git», USER=»git»

Этот раздел определяет команду, которая будет использоваться для запуска Gogs, автоматически выполняет её при помощи Supervisor, а также задаёт расположение лог-файлов и соответствующих переменных окружения.

Примечание: Больше информации о настройках Supervisor можно найти в этом руководстве.

sudo service supervisor restart

Чтобы проверить, запущен ли сервис Gogs, используйте следующую команду:

В результате на экране появится:

Также можно проверить файл stdout.log, чтобы убедиться, что сервис запущен:

На экране появится следующая строка:

2015/03/09 14:24:42 [I] Gogs: Go Git Service 0.5.16.0301 Beta

Кроме того, в браузере можно посетить страницу http://your_server_ip:3000/. Если все работает должным образом, на экране появится форма установки, но пока что не нужно заполнять её.

4: Nginx как обратный прокси-сервер

На данном этапе нужно настроить Nginx в качестве обратного прокси, чтобы иметь возможность привязать доменное имя к Gogs.

Чтобы установить Nginx:

Затем создайте конфигурационный файл Nginx для Gogs:

sudo nano /etc/nginx/sites-available/gogs

Внесите в него следующий код, заменив your_server_ip IP-адресом сервера (можно также внести сюда домен).

Создайте символическую ссылку на этот файл, чтоб Nginx мог использовать его.

Примечание: Чтобы узнать о настройке виртуальных хостов Nginx больше, читайте эту статью.

В завершение перезапустите Nginx, чтобы активировать новые настройки:

sudo service nginx restart

При помощи браузера откройте страницу http://your_server_ip/, не указывая порт.

5: Инициализация Gogs

Посетите http://your_server_ip/install и задайте следующие опции (многие из них внесены автоматически, но не забудьте указать данные своего сервера в некоторых строках):

В первом разделе Gogs требует указать СУБД (MySQL, PostgreSQL или SQLite3):

В следующем разделе (General Settings of Gogs) внесите:

Пропустите опциональные настройки электронной почты и уведомлений, а затем выберите имя и пароль администратора (раздел Admin Account Settings) и укажите свой электронный адрес.

Затем нажмите Install Gogs.

6: Тестирование установки Gogs

Теперь нужно протестировать установку Gogs при помощи простой проверки pull/push.

Откройте http://your_server_ip/repo/create и создайте репозиторий по имени my-test-repo, а затем нажмите на Initialize this repository with a README.md.

Теперь у вас есть возможность клонировать этот репозиторий. Перейдите в домашний каталог:

И клонируйте репозиторий:

git clone http://your_server_ip/your_admin_username/my-test-repo.git

Откройте каталог репозитория:

echo ‘I love Gogs!’ >> README.md

Создайте сообщение о коммите и выполните команду push. Команда запросит имя пользователя и пароль Gogs.

Источник

Как скачать игры GOG и выбрать, где их установить

Хотя каждая игра зависит от своей платформы, мы можем использовать GOG как для их загрузки, так и для игры (после запуска соответствующего клиента) и даже для просмотра всей статистики и трофеев. Ниже мы объясним, как это делается и как мы можем контролировать все аспекты загрузки игр с этой платформы.

Контроль загрузки игр GOG

Параметры загрузки и установки игры GOG находятся в ее Настройки МЕНЮ . Чтобы добраться до него, нам нужно нажать на значок шестеренки в верхней левой части окна программы.

В окне конфигурации программы мы должны выбрать » Установка, обновление », Чтобы увидеть различные параметры настройки для этого процесса.

Выбираем куда устанавливать игры

» Установить игры ”- это тот раздел, который позволит нам выбрать, где мы хотим, чтобы игры, загружаемые с GOG, были установлены, и как мы хотим это делать.

Первое, что мы сможем сделать, это выбрать язык, который мы хотим по умолчанию для игр. Этот язык будет тем языком, который загружается и активируется по умолчанию во всех играх, когда он доступен. Если игра не переведена на наш язык, то по умолчанию она будет отображаться на английском языке.

Мы также собираемся найти раздел, в котором мы можем выбрать папку для установки игр. По умолчанию все они будут загружены и установлены в папку под названием Games в каталоге, в котором установлен клиент. Кроме того, мы также можем выбрать, хотим ли мы, чтобы игры создавали собственные ярлыки на рабочем столе или нет.

Наконец, мы также сможем выбрать, где сохранять другие загрузки, которые могут быть связаны с играми (например, руководства или книги по искусству). По умолчанию они будут сохранены в собственной папке игры, но при желании мы можем изменить путь.

Отрегулируйте скорость загрузки игр GOG

Параметры скорости и загрузки, которые мы можем настроить, можно найти в разделе » Пропускная способность »Внизу.

Освободи Себя Клиент GOG Galaxy позволит нам выбрать скорость загрузки, которую мы хотим ограничить в программе. Если мы активируем его, мы сможем установить желаемый лимит в желаемых единицах. Например, мы можем ограничить его до 10 МБ / с (100 Мбит / с), чтобы и загрузки, и обновления игр не использовали скорость, превышающую это ограничение.

Мы также сможем выбрать, хотим ли мы запрограммировать это ограничение на определенный диапазон часов. Это полезно, например, если мы хотим, чтобы ограничение применялось только к нашим рабочим часам, но в остальное время мы не хотим, чтобы программа была ограничена.

Конечно, как и другие клиенты, мы также найдем вариант, который позволит нам приостанавливать загрузку во время игры. Таким образом мы можем сэкономить пропускную способность и диск, чтобы получить больше FPS.

Скачать игру GOG

Кроме того, рядом с кнопкой установки игры мы найдем кнопку «Дополнительно». Оттуда мы сможем получить доступ к индивидуальным загрузкам каждого из элементов игры. Например, мы можем загрузить базовую игру, обновления и даже каждый игровой ресурс или язык отдельно.

После установки игры из GOG мы сможем настраивать и управлять установкой. Например, мы можем изменить язык, подписаться на бета-версию игры и даже активировать специальные функции, такие как синхронизация сохраненных игр или оверлейная панель Galaxy.

Удалить игру

Когда игра нам надоест, мы можем удалить ее, чтобы освободить место. Если мы активировали синхронизацию сохраненных игр в облаке, они будут сохранены, чтобы иметь возможность использовать их позже, если мы решим переустановить игру.

Чтобы удалить игру, мы должны выполнить те же действия, что и для удаления любой программы. То есть мы перейдем к Настройки> Windows 10 Раздел приложений и найдите игру в списке приложений, установленных на ПК. Оттуда мы будем следовать обычным шагам, чтобы удалить игру и освободить место.

Источник

brief introduction

Gopsutil is a Python tool library * * [psutil]( https://link.zhihu.com/?target=https%3A//github.com/giampaolo/psutil )**The transplanted version of Golang can help us easily obtain various system and hardware information. Gopsutil shields the differences between various systems for us and has very strong portability. With gopsutil, we no longer need to use syscall to call corresponding system methods for different systems. Even better, there is no cgo code in the implementation of gopsutil, which makes cross compilation possible.

gopsutil divides different functions into different sub packages:

• CPU: CPU related;
• Disk: disk related;
• Docker: docker related;
• Host: host related;
• mem: memory related;
• net: network related;
• Process: process related;
• winservices: Windows service related.

Import package

import github.com/shirou/gopsutil

Collect CPU Information

We know that there are two types of CPU cores, one is physical core and the other is logical core. The number of physical cores is the actual number of CPUs on the motherboard. A physical CPU can have multiple cores. These cores are called logical cores. CPU related functions in gopsutil are in the CPU sub package, which provides interfaces for obtaining the number of physical and logical cores and CPU utilization:

• Counts(logical bool): pass in false to return the number of physical cores; pass in true to return the number of logical cores;
• Percent(interval time.Duration, percpu bool): indicates to obtain the CPU utilization within the interval. When percpu is false, obtain the total CPU utilization. When percpu is true, obtain the utilization of each CPU respectively, and return a value of [] float64 type.

physicalCnt, _ := cpu.Counts(false) // cpu physical cores
logicalCnt, _ := cpu.Counts(true)   // Number of cpu logical cores
fmt.Printf("physical count:%d logical count:%dn", physicalCnt, logicalCnt)

// Obtain the total CPU utilization rate and the respective utilization rate of each CPU within 3s
totalPercent, _ := cpu.Percent(3*time.Second, false)	// Total CPU utilization
perPercents, _ := cpu.Percent(3*time.Second, true)	// Utilization of each CPU
fmt.Printf("total percent:%v per percents:%v", totalPercent, perPercents)

The above code output:

physical count:6 logical count:12
total percent:[1.078981441519206] per percents:[13.19796954314721 1.5706806282722512 23.036649214659686 2.094240837696335 13.541666666666666 1.5625 8.854166666666668 1.0471204188481675 4.6875 1.5625 4.712041884816754 1.0416666666666665]

detailed information

Call CPU Info() to get the details of CPU and return [] CPU InfoStat:

func main() {
  infos, _ := cpu.Info()
  for _, info := range infos {
    data, _ := json.MarshalIndent(info, "", " ")
    fmt.Print(string(data))
  }
}

To facilitate viewing, I use JSON to output the results:

{
 "cpu": 0,
 "vendorId": "GenuineIntel",
 "family": "205",
 "model": "",
 "stepping": 0,
 "physicalId": "BFEBFBFF000A0653",
 "coreId": "",
 "cores": 12,	// Number of cpu logical cores
 "modelName": "Intel(R) Core(TM) i5-10400 CPU @ 2.90GHz",
 "mhz": 2904,
 "cacheSize": 0,
 "flags": [],
 "microcode": ""
}

It can be seen from the results that the CPU is Intel’s i5-10400 series, with a frequency of 2.90GHz. The above is the return result of my running on Windows. GitHub is used internally COM / stackexchange / WMI library. Under Linux, each logical CPU will return an InfoStat structure.

CPU load

info, _ := load.Avg()
fmt.Printf("%vn", info)

{
    "load1":0,
    "load5":0,
    "load15":0
}

Time occupation

Call CPU Times (percpu bool) can obtain the total CPU and the time occupation of each individual CPU from startup. Passing in percpu=false returns the total, and passing in percpu=true returns the single. The time usage of each CPU is a TimeStat structure:

// src/github.com/shirou/gopsutil/cpu/cpu.go
type TimesStat struct {
  CPU       string  `json:"cpu"`	//CPU identification. If it is total, this field is' CPU total ', otherwise it is' cpu0', 'cpu1';
  User      float64 `json:"user"`	//User time occupation (user status)
  System    float64 `json:"system"`	//System time occupation (kernel state)
  Idle      float64 `json:"idle"`	//free time
  Nice      float64 `json:"nice"`
  Iowait    float64 `json:"iowait"`
  Irq       float64 `json:"irq"`
  Softirq   float64 `json:"softirq"`
  Steal     float64 `json:"steal"`
  Guest     float64 `json:"guest"`
  GuestNice float64 `json:"guestNice"`
}

For example:

func main() {
  infos, _ := cpu.Times(true)
  for _, info := range infos {
    data, _ := json.MarshalIndent(info, "", " ")
    fmt.Print(string(data))
  }
}

To facilitate viewing, I use JSON to output the results. Here is one of the outputs:

{
 "cpu": "cpu0",
 "user": 674.46875,
 "system": 1184.984375,
 "idle": 7497.1875,
 "nice": 0,
 "iowait": 0,
 "irq": 75.578125,
 "softirq": 0,
 "steal": 0,
 "guest": 0,
 "guestNice": 0
}

Collect disk information

The sub package disk is used to obtain disk information. Disk can obtain IO statistics, partition and utilization information. The following are introduced in turn.

IO statistics

Call disk Iocounters() function, the returned IO statistics are represented by map[string]IOCountersStat type. Each partition has a structure, the key is the partition name, and the value is statistical information. Some fields of the statistical structure are extracted here, mainly including the number of reads and writes, bytes and time:

// src/github.com/shirou/gopsutil/disk/disk.go
type IOCountersStat struct {
  ReadCount        uint64 `json:"readCount"`
  MergedReadCount  uint64 `json:"mergedReadCount"`
  WriteCount       uint64 `json:"writeCount"`
  MergedWriteCount uint64 `json:"mergedWriteCount"`
  ReadBytes        uint64 `json:"readBytes"`
  WriteBytes       uint64 `json:"writeBytes"`
  ReadTime         uint64 `json:"readTime"`
  WriteTime        uint64 `json:"writeTime"`
  // ...
}

For example:

func main() {
  mapStat, _ := disk.IOCounters()	//  IO statistics
  for name, stat := range mapStat {
    fmt.Println(name)
    data, _ := json.MarshalIndent(stat, "", "  ")
    fmt.Println(string(data))
  }
}

The output includes all partitions. I only show one here:

C:	// c disk
{
  "readCount": 2249456,      
  "mergedReadCount": 0,      
  "writeCount": 6522173,     
  "mergedWriteCount": 0,     
  "readBytes": 59965126656,  
  "writeBytes": 142391553536,
  "readTime": 5406,
  "writeTime": 3562,
  "iopsInProgress": 0,       
  "ioTime": 0,
  "weightedIO": 0,
  "name": "C:",
  "serialNumber": "",
  "label": ""
}

Note that disk Iocounters() can pass in a variable number of string parameters to identify the partition, which is not valid on Windows.

partition

Call disk The PartitionStat (all bool) function returns partition information. If all = false, only the actual physical partition (including hard disk, CD-ROM and USB) is returned, and other virtual partitions are ignored. If all = true, all partitions are returned. The return type is [] PartitionStat, and each partition corresponds to a PartitionStat structure:

// src/github.com/shirou/gopsutil/disk/
type PartitionStat struct {
  Device     string `json:"device"`		// Partition ID is in the format of 'C:' on Windows
  Mountpoint string `json:"mountpoint"`	// Mount point is the starting location of the file path of the partition
  Fstype     string `json:"fstype"`		// File system types: FAT, NTFS, etc. are commonly used in Windows, and ext, ext2, ext3, etc. are used in Linux
  Opts       string `json:"opts"`		// Options, system related
}

For example:

func main() {
  infos, _ := disk.Partitions(false)
  for _, info := range infos {
    data, _ := json.MarshalIndent(info, "", "  ")
    fmt.Println(string(data))
  }
}

My Windows machine output (only show the first partition):

{
  "device": "C:",      
  "mountpoint": "C:",  
  "fstype": "NTFS",    
  "opts": "rw.compress"
}

According to the above output, my first partition is C:, and the file system type is NTFS.

Utilization rate

Call disk Usage (path string) to obtain the usage of the disk where the path path is located, and return a UsageStat structure:

// src/github.com/shirou/gopsutil/disk.go
type UsageStat struct {
  Path              string  `json:"path"`	// Path, passed in parameters
  Fstype            string  `json:"fstype"`	// file system type
  Total             uint64  `json:"total"`	// Total capacity of this zone
  Free              uint64  `json:"free"`	// Free capacity
  Used              uint64  `json:"used"`	// Used capacity
  UsedPercent       float64 `json:"usedPercent"`	// Percentage used
  InodesTotal       uint64  `json:"inodesTotal"`
  InodesUsed        uint64  `json:"inodesUsed"`
  InodesFree        uint64  `json:"inodesFree"`
  InodesUsedPercent float64 `json:"inodesUsedPercent"`
}

For example:

func main() {
  info, _ := disk.Usage("E:/code")
  data, _ := json.MarshalIndent(info, "", "  ")
  fmt.Println(string(data))
}

Since the usage of the disk is returned, the paths E:/code and E: return the same result, but the Path field in the structure is different. Program output:

{
  "path": "E:/code",
  "fstype": "",
  "total": 339303460864,
  "free": 336575107072,
  "used": 2728353792,
  "usedPercent": 0.804104321557033,
  "inodesTotal": 0,
  "inodesUsed": 0,
  "inodesFree": 0,
  "inodesUsedPercent": 0
}

Collect host information

The sub package host can obtain host related information, such as boot time, kernel version number, platform information and so on.

Startup time

host.BootTime() returns the timestamp of the host boot time:

func main() {
  timestamp, _ := host.BootTime()
  t := time.Unix(int64(timestamp), 0)
  fmt.Println(t.Local().Format("2006-01-02 15:04:05"))
}

Get the boot time first, and then go through the above. Time UNIX () converts it to time Time type, the last output time in 2006-01-02 15:04:05 format:

2020-04-06 20:25:32

Kernel version and platform information

func main() {
  version, _ := host.KernelVersion()
  fmt.Println(version)

  platform, family, version, _ := host.PlatformInformation()
  fmt.Println("platform:", platform)	// Operating system information
  fmt.Println("family:", family)
  fmt.Println("version:", version)
}

Run output on my Win10:

10.0.19042 Build 19042
platform: Microsoft Windows 10 Pro
family: Standalone Workstation    
version: 10.0.19042 Build 19042

end user

host.Users() returns the user information connected to the terminal. Each user has a UserStat structure:

// src/github.com/shirou/gopsutil/host/host.go
type UserStat struct {
  User     string `json:"user"`
  Terminal string `json:"terminal"`
  Host     string `json:"host"`
  Started  int    `json:"started"`
}

The fields are clear at a glance. See the example:

func main() {
  users, _ := host.Users()
  for _, user := range users {
    data, _ := json.MarshalIndent(user, "", " ")
    fmt.Println(string(data))
  }
}

Collect memory information

Get physical memory information

We demonstrated how to use mem Virtualmemory() to get memory information. This function returns only physical memory information.

import "github.com/shirou/gopsutil/mem"
//mem. The memory structure information returned by the virtual memory () method VirtualMemoryStat
v, _ := mem.VirtualMemory()
fmt.Println(v)

The output is as follows:

{
  "total": 17013055488,		// Total memory
  "available": 8491429888,	// Available memory
  "used": 8521625600,		// Used memory
  "usedPercent": 50,		// Memory usage percentage
  "free": 8491429888,		// Unused memory
  "active": 0,
  "inactive": 0,
  "wired": 0,
  "laundry": 0,
  "buffers": 0,
  "cached": 0,
  "writeBack": 0,
  "dirty": 0,
  "writeBackTmp": 0,
  "shared": 0,
  "slab": 0,
  "sreclaimable": 0,
  "sunreclaim": 0,
  "pageTables": 0,
  "swapCached": 0,
  "commitLimit": 0,
  "committedAS": 0,
  "highTotal": 0,
  "highFree": 0,
  "lowTotal": 0,
  "lowFree": 0,
  "swapTotal": 0,
  "swapFree": 0,
  "mapped": 0,
  "vmallocTotal": 0,
  "vmallocUsed": 0,
  "vmallocChunk": 0,
  "hugePagesTotal": 0,
  "hugePagesFree": 0,
  "hugePageSize": 0
}

Get swap memory information

We can also use mem Swapmemory() gets the information of swap memory, which is stored in the structure SwapMemoryStat:

// src/github.com/shirou/gopsutil/mem/
type SwapMemoryStat struct {
  Total       uint64  `json:"total"`	// Total memory
  Used        uint64  `json:"used"`		// Memory used
  Free        uint64  `json:"free"`		// idle memory
  UsedPercent float64 `json:"usedPercent"`	// Memory usage
  Sin         uint64  `json:"sin"`
  Sout        uint64  `json:"sout"`
  PgIn        uint64  `json:"pgin"`		// Number of pages loaded
  PgOut       uint64  `json:"pgout"`	// Pages eliminated
  PgFault     uint64  `json:"pgfault"`	// Number of page missing errors
}

The meaning of the field is easy to understand. We will focus on the three fields PgIn/PgOut/PgFault. Swap memory is in pages. If a page fault occurs, the operating system will load some pages from the disk into memory and eliminate some pages in memory according to a specific mechanism. PgIn indicates the number of loaded pages, PgOut eliminated pages, and PgFault page missing errors.

For example:

func main() {
  swapMemory, _ := mem.SwapMemory()
  data, _ := json.MarshalIndent(swapMemory, "", " ")
  fmt.Println(string(data))
}

The output is as follows:

{
 "total": 24093069312,
 "used": 12682260480,
 "free": 11410808832,
 "usedPercent": 52.638625306587095,
 "sin": 0,
 "sout": 0,
 "pgin": 0,
 "pgout": 0,
 "pgfault": 0,
 "pgmajfault": 0
}

Collect process information

Process can be used to obtain the process information currently running in the system, create a new process, and perform some operations on the process.

func main() {
  var rootProcess *process.Process
  processes, _ := process.Processes()
  for _, p := range processes {
    if p.Pid == 0 {
      rootProcess = p
      break
    }
  }

  fmt.Println(rootProcess)

  fmt.Println("children:")
  children, _ := rootProcess.Children()
  for _, p := range children {
    fmt.Println(p)
  }
}

Call process first Processes () gets all the processes running in the current system, then finds the Pid 0 process, the first process of the operating system, and finally calls Children() to return to its sub process. There are also many ways to obtain process information. If you are interested, you can check the documentation~

Collect Windows service information

The winservices sub package can obtain the Service information in the Windows system, and golang.com is used internally Org / X / sys package. In winservices, a Service corresponds to a Service structure:

// src/github.com/shirou/gopsutil/winservices/winservices.go
type Service struct {
  Name   string
  Config mgr.Config
  Status ServiceStatus
  // contains filtered or unexported fields
}

mgr.Config is the package golang Org / X / sys, which records the service type, startup type (automatic / manual), binary file path and other information in detail:

// src/golang.org/x/sys/windows/svc/mgr/config.go
type Config struct {
  ServiceType      uint32
  StartType        uint32
  ErrorControl     uint32
  BinaryPathName   string
  LoadOrderGroup   string
  TagId            uint32
  Dependencies     []string
  ServiceStartName string
  DisplayName      string
  Password         string
  Description      string
  SidType          uint32
  DelayedAutoStart bool
}

The ServiceStatus structure records the status of the service:

// src/github.com/shirou/gopsutil/winservices/winservices.go
type ServiceStatus struct {
  State         svc.State	//It is in service status, including stopped, running, suspended, etc
  Accepts       svc.Accepted	// Indicates which operations the service receives, including pause, resume and session switching
  Pid           uint32	// Process ID
  Win32ExitCode uint32	// Application exit status code
}

In the following program, I output the names, binary file paths and status of all services in the system to the console:

func main() {
  services, _ := winservices.ListServices()

  for _, service := range services {
    newservice, _ := winservices.NewService(service.Name)
    newservice.GetServiceDetail()
    fmt.Println("Name:", newservice.Name, "Binary Path:", newservice.Config.BinaryPathName, "State: ", newservice.Status.State)
  }
}

Notice that you call WinServices The Service object information returned by ListServices () is incomplete. We create a service with the name of the service through NewService(), and then call the GetServiceDetail () method to get the details of the service. You cannot directly use service Call GetServiceDetail() because the object returned by ListService() lacks the necessary system resource handle (to save resources), calling GetServiceDetail() method will panic!!!

Error and timeout

Since most functions involve bottom-level system calls, errors and timeouts are inevitable. Almost all interfaces have two return values, the second as an error. In the previous example, we ignored the error in order to simplify the code. In practical use, it is recommended to deal with the error.

In addition, most interfaces are a pair, one without context A parameter of type context. The other parameter with this type is used for context control. In case of internal call error or timeout, it can be handled in time to avoid waiting for a long time to return. In fact, without context The function of context parameter is internally based on context Background() is a parameter call with context Function of context:

// src/github.com/shirou/gopsutil/cpu_windows.go
func Times(percpu bool) ([]TimesStat, error) {
  return TimesWithContext(context.Background(), percpu)
}

func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) {
  // ...
}