text:
---
pagetitle: Release Notes for STM32F7xx CMSIS
lang: en
---

::: {.row}
::: {.col-sm-12 .col-lg-4}

::: {.card .fluid}
::: {.sectione .dark}

# **Release Notes for STM32F7xx CMSIS**
Copyright © 2019 STMicroelectronics\

[![ST logo](_htmresc/st_logo.png)](https://www.st.com){.logo}

:::
:::

# License

This software component is licensed by ST under BSD 3-Clause license, the "License"; You may not use this file except in compliance with the License. You may obtain a copy of the License at:

[https://opensource.org/licenses/BSD-3-Clause](https://opensource.org/licenses/BSD-3-Clause)

:::

::: {.col-sm-12 .col-lg-8}
# __Update History__

::: {.collapse}
<input type="checkbox" id="collapse-section1_2_5"  aria-hidden="true">
__V1.2.5 / 13-February-2020__

## Main Changes
   - Add ADC missing calibration address for Vref and Temperature sensor.
   - Align GPIO Bits Definitions to use _POS and _MSK.
   - Add IS_UART_WAKEUP_FROMSTOP_INSTANCE macro for STM32F765xx, STM32F767xx, STM32F769xx,STM32F777xx and STM32F779xx devices.
   - Add missing USART Bits Definitions in USART_CR1, USART_CR3, USART_ISR and USART_ICR registers for STM32F765xx, STM32F767xx, STM32F769xx,STM32F777xx and STM32F779xx devices.
   - Add USB missing Bit Definition in USB_OTG_GUSBCFG register for STM32F722xx and STM32F732xx devices
   - Remove dublicated Bits Definitions for OTG register
   - Remove IS_TIM_SYNCHRO_INSTANCE macro.

:::

::: {.collapse}
<input type="checkbox" id="collapse-section1_2_4"  aria-hidden="true">
__V1.2.4 / 08-February-2019__

## Main Changes
- CRYP
   - Update CMSIS devices with correct CRYP data input register name: DIN instead of DR
- SAI
   -Fix frame length in SAI_xFRCR_FSALL & SAI_xFRCR_FRL bits description
- USB
   - Add missing Bits Definitions in USB_OTG_DOEPMSK register
      - USB_OTG_DOEPMSK_AHBERRM
      - USB_OTG_DOEPMSK_OTEPSPRM
      - USB_OTG_DOEPMSK_BERRM
      - USB_OTG_DOEPMSK_NAKM
      - USB_OTG_DOEPMSK_NYETM
   - Add missing Bits Definitions in USB_OTG_DIEPINT register
      - USB_OTG_DIEPINT_INEPNM
      - USB_OTG_DIEPINT_AHBERR
      - USB_OTG_DOEPINT_OUTPKTERR
      -  USB_OTG_DOEPINT_NAK
      - USB_OTG_DOEPINT_STPKTRX
   - Add missing Bits Definitions in USB_OTG_DCFG register
      - USB_OTG_DCFG_XCVRDLY
      - USB_OTG_DCFG_ERRATIM
   - Add IS_PCD_ALL_INSTANCE() and IS_HCD_ALL_INSTANCE() defines
   - Remove GADPCTL parameter from USB_OTG_GlobalTypeDef() structure
   - Remove GPWRDN parameter from USB_OTG_GlobalTypeDef5° STRUCTURE
- DFSDM
   - Align Bit naming for DFSDM_FLTICR register: DFSDM_FLTICR_CLRSCSDF--> DFSDM_FLTICR_CLRSCDF
- CEC
   - Align Bit naming for CEC_RXDR register: CEC_TXDR_RXD--> CEC_RXDR_RXD
- QSPI
   - Update FLEVEL field in QuadSPI Status register definition to be compliant with user manual

:::

::: {.collapse}
<input type="checkbox" id="collapse-section1_2_3"  aria-hidden="true">
__V1.2.3 / 29-June-2018__

## Main Changes

- Add the support of __STM32F730xx and  STM32F750xx__  devices
    - Add "stm32f730xx.h" and "stm32f750xx.h" header files
    - Add startup files "startup_stm32f730xx.s" and "startup_stm32f750xx.s" for EWARM, MDK-ARM and SW4STM32 toolchains
    - Add Linker files "stm32f730xx_flash.icf", "stm32f730xx_sram.icf" and "stm32f730xx_ITCM_flash.icf" used within EWARM Workspaces
    - Add Linker files "stm32f750xx_flash.icf", "stm32f750xx_sram.icf" and "stm32f750xx_ITCM_flash.icf" used within EWARM Workspaces

:::

::: {.collapse}
<input type="checkbox" id="collapse-section1_2_2"  aria-hidden="true">
__V1.2.2 / 26-December-2017__

## Main Changes

- Update bits definition for USBPHYC_PLL1 and USBPHYC_LDO registers to be inline with products documentation.

:::

::: {.collapse}
<input type="checkbox" id="collapse-section1_2_1"  aria-hidden="true">
__V1.2.1 / 25-August-2017__

## Main Changes

- Update FLASHSIZE_BASE and UID_BASE defined values for STM32F72x and STM32F73x devices.
- Update stm32f7xx.h to include stm32f7xx_hal.h file instead of stm32f7xx_hal_conf.h file
- Remove Date and Version from header files

:::

::: {.collapse}
<input type="checkbox" id="collapse-section1_2_0"  aria-hidden="true">
__V1.2.0 / 30-December-2016__

## Main Changes

- Add the support of __STM32F722xx, STM32F723xx, STM32F732xx and STM32F733xx__ devices
   - Add "stm32f722xx.h", "stm32f723xx.h", "stm32f732xx.h" and "stm32f733xx.h" header files
   - Add startup files "startup_stm32f722xx.s", "startup_stm32f723xx.s", "startup_stm32f732xx.s" and "startup_stm32f733xx.s" for EWARM, MDK-ARM and SW4STM32 toolchains
   - Add Linker files "stm32f722xx_flash.icf", "stm32f722xx_sram.icf" and "stm32f722xx_ITCM_flash.icf" used within EWARM Workspaces
   - Add Linker files "stm32f723xx_flash.icf", "stm32f723xx_sram.icf" and "stm32f723xx_ITCM_flash.icf" used within EWARM Workspaces
   - Add Linker files "stm32f732xx_flash.icf", "stm32f732xx_sram.icf" and "stm32f732xx_ITCM_flash.icf" used within EWARM Workspaces
   - Add Linker files "stm32f733xx_flash.icf", "stm32f733xx_sram.icf" and "stm32f733xx_ITCM_flash.icf" used within EWARM Workspaces
- All devices header files
   - Use _Pos and _Mask macro for all Bit Definitions
   - Use DAC1 instance instead of DAC
   - Add IS_SMBUS_ALL_INSTANCE macro
   - Add ADC123_COMMON instance
   - Add DMA_SxPAR_PA, DMA_SxM0AR_M0A and DMA_SxM1AR_M1A registers Bits Definition
   - Add DBGMCU_APB1_FZ_DBG_LPTIM1_STOP and DBGMCU_APB1_FZ_DBG_I2C4_SMBUS_TIMEOUT Bits Definition
   - Add FLASH_OTP_BASE and FLASH_OTP_END defines
   - Add MACDBGR register Bits Definition
   - Add GPIO_AFRL and GPIO_AFRH registers Bits Definition
   - Add TIM2_OR, TIM5_OR and TIM11_OR registers Bits Definition
   - Add TIM1_AF1_BKINP Bit Definition for TIM1_AF1 register
   - Add IS_TIM_32B_COUNTER_INSTANCE, IS_TIM_BREAK_INSTANCE, IS_TIM_BREAKSOURCE_INSTANCE and IS_TIM_BKIN2_INSTANCE, IS_TIM_CLOCK_DIVISION_INSTANCE, IS_TIM_REPETITION_COUNTER_INSTANCE, IS_TIM_CLOCKSOURCE_ETRMODE1_INSTANCE, IS_TIM_CLOCKSOURCE_ETRMODE2_INSTANCE, IS_TIM_HALL_SENSOR_INTERFACE_INSTANCE and IS_TIM_COMMUTATION_EVENT_INSTANCE macros
   - Add IS_USART_AUTOBAUDRATE_DETECTION_INSTANCE, IS_UART_HALFDUPLEX_INSTANCE and IS_UART_LIN_INSTANCE macros
   - Remove TIM_SMCR_OCCS Bit Definition for TIM_SMCR register
   - Remove USART_ISR_WUF and USART_ISR_REACK Bits Definition from USART_ISR register
   - Rename USART_CR1_M_0 / USART_CR1_M_1 defines to USART_CR1_M0 / USART_CR1_M1
   - Rename PACKAGESIZE_BASE define to PACKAGE_BASE
   - Rename RTC_OR_ALARMTYPE Bit Definition to RTC_OR_ALARMOUTTYPE
   - Rename RTC_CR_BCK Bit Definition to RTC_CR_BKP in RTC_CR register

:::

::: {.collapse}
<input type="checkbox" id="collapse-section1_1_1"  aria-hidden="true">
__V1.1.1 / 01-July-2016__

## Main Changes

- stm32f7xx.h
   - update to respectively associate STM32F778xx and STM32F768xx devices to STM32F779xx and STM32F769xx devices

:::

::: {.collapse}
<input type="checkbox" id="collapse-section1_1_0"  aria-hidden="true">
__V1.1.0 / 22-April-2016__

## Main Changes

- Add the support of __STM32F765xx, STM32F767xx, STM32F768xx, STM32F769xx, STM32F777xx, STM32F778xx and STM32F779xx__ devices
   - Add "stm32f765xx.h", "stm32f767xx.h", "stm32f769xx.h", "stm32f777xx.h" and "stm32f779xx.h" header files
   - Add startup files "startup_stm32f765xx.s", "startup_stm32f767xx.s", "startup_stm32f769xx.s", "startup_stm32f777xx.s" and "startup_stm32f779xx.s" for EWARM, MDK-ARM and SW4STM32 toolchains
   - Add Linker files "stm32f765xx_flash.icf", "stm32f765xx_sram.icf" and "stm32f765xx_ITCM_flash.icf" used within EWARM Workspaces
   - Add Linker files "stm32f767xx_flash.icf", "stm32f767xx_sram.icf" and "stm32f767xx_ITCM_flash.icf" used within EWARM Workspaces
   - Add Linker files "stm32f769xx_flash.icf", "stm32f769xx_sram.icf" and "stm32f769xx_ITCM_flash.icf" used within EWARM Workspaces
   - Add Linker files "stm32f777xx_flash.icf", "stm32f777xx_sram.icf" and "stm32f777xx_ITCM_flash.icf" used within EWARM Workspaces
   - Add Linker files "stm32f779xx_flash.icf", "stm32f779xx_sram.icf" and "stm32f779xx_ITCM_flash.icf" used within EWARM Workspaces
   - STM32F768xx cmsis files are associated with STM32F767xx ones, as there is no difference between these devices on HAL side
   - STM32F778xx cmsis files are associated with STM32F777xx ones, as there is no difference between these devices on HAL side
- All devices header files
   - Update Bit Definition names in DCMI_RISR / DCMI_IER registers
   - Update Bit Definition names in DMA2D_CR / DMA2D_FGPFCCR / DMA2D_BGPFCCR / DMA2D_OPFCCR registers
   - Update QUADSPI_CR_FTHRES Bit Definition in QUADSPI_CR register
   - Rename SAI_xFRCR_FSPO to SAI_xFRCR_FSPOL in SAI_xFRCR register
   - Rename ADC_CSR_DOVRx Bit Definition to ADC_CSR_OVRx in ADC_CSR register
   - Rename LTDC_GCR_DTEN Bit Definition to LTDC_GCR_DEN in LTDC_GCR register
   - Rename PWR_CSR1_UDSWRDY Bit Definition to PWR_CSR1_UDRDY in PWR_CSR1 register
   - Rename RTC_TAMPCR_TAMPx_TRG Bit Definition to RTC_TAMPCR_TAMPxTRG in RTC_TAMPCR register
   - Rename USART_ISR_LBD Bit Definition to USART_ISR_LBDF in USART_ISR register
   - Rename IS_SAI_BLOCK_PERIPH macro to IS_SAI_ALL_INSTANCE
   - Rename DCMI_ICR_OVF_ISC Bit Definition to DCMI_ICR_OVR_ISC
   - Rename DMA2D_IFSR register to DMA2D_IFCR
   - Rename EXTI_IMR_MRx Bit Definition to EXTI_IMR_IM0x
   - Rename EXTI_EMR_MRx Bit Definition to EXTI_EMR_EMx
   - Fix LPTIM_CR_SNGSTRT Bit Definition value in LPTIM_CR register
   - Fix mask incorrect naming in DBGMCU_APB2_FZ register
   - Fix Bits Definition for SYSCFG_EXTICR4_EXTI13_PI and SYSCFG_EXTICR4_EXTI13_PJ
   - Add DAC_CR_DMAUDRIEx Bit Definition in DAC_CR register
   - Add a new mask EXTI_IMR_IM in EXTI bits definition: Interrupt Mask All
   - Add UID_BASE define for Unique ID register base address
   - Add FLASHSIZE_BASE define for register base address
   - Add PACKAGESIZE_BASE define for register base address
   - Add FLASH_SECTOR_TOTAL define for total Flash sector number
   - Add Bits Definition for DCMI_ESCR, DCMI_ESUR, DCMI_CWSTRT, DCMI_CWSIZE and DCMI_DR registers
   - Add PWR_CSR1_EIWUP Bit Definition in PWR_CSR1 register
   - Add IP version define for QSPI: QSPI_V1_0
   - Add IS_UART_DRIVER_ENABLE_INSTANCE macro
   - Apply an 'U' suffix to all constants of 'unsigned' type (MISRA-C 2004 rule 10.6)
   - Remove uint32_t cast in all defines
   - Remove DMA_SxCR_ACK Bit Definition in DMA_SxCR register
   - Remove I2C_CR1_SWRST / I2C_CR1_WUPEN Bit Definitions in I2C_CR1 register
   - Keep the same DCMI register names (RISR, MISR, CWSTRTR and CWSIZER) as F4 family
- system_stm32f7xx.c/.h files
   - Remove external memories configuration from the system_stm32f7xx.c common file (moved to Template Projects)
   - Add declaration of AHBPrescTable / APBPrescTable constant tables
- stm32f7xx.h
   - Rename __STM32F7xx_CMSIS_DEVICE_VERSION_xx defines to __STM32F7_CMSIS_VERSION_xx (MISRA-C 2004 rule 5.1)

:::

::: {.collapse}
<input type="checkbox" id="collapse-section1_0_3"  aria-hidden="true">
__V1.0.3 / 13-November-2015__

## Main Changes

- stm32f745xx.h, stm32f746xx.h and stm32f756xx.h files
   - update __CM7_REV with proper Cortex M7 core revision
   - update SAI_xCR2_CPL bit definition
   - update WWDG bits naming to be aligned with reference manual
   - rename I2C_CR1_DFN bit to I2C_CR1_DNF
   - remove OR register definition from LPTIM_TypeDef structure
- system_stm32f7xx.c
   - update SystemInit_ExtMemCtl() function implementation to allow simultaneous use of SDRAM and SRAM external memories

:::

::: {.collapse}
<input type="checkbox" id="collapse-section1_0_2"  aria-hidden="true">
__V1.0.2 / 21-September-2015__

## Main Changes

- stm32f745xx.h, stm32f746xx.h and stm32f756xx.h files
   - add new define USB_OTG_DOEPMSK_OTEPSPRM
   - add new define USB_OTG_DOEPINT_OTEPSPR

:::

::: {.collapse}
<input type="checkbox" id="collapse-section1_0_1"  aria-hidden="true">
__V1.0.1 / 25-June-2015__

## Main Changes

- stm32f745xx.h, stm32f746xx.h and stm32f756xx.h files
   - update IDR field declaration in CRC_TypeDef sructure
   - add I2C Own address 2 mask bits defininition in the I2C_OAR2 register
   - update SAI_xSR_FLVL_2 bit definition
- stm32f756xx.h file
   - rename HASH_STR_NBWx bits definition to HASH_STR_NBLWx
   - rename HASH_IMR_DINIM bit definition to HASH_IMR_DINIE
   - rename HASH_IMR_DCIM bit definition to HASH_IMR_DCIE

:::

::: {.collapse}
<input type="checkbox" id="collapse-section1_0_0"  aria-hidden="true">
__V1.0.0 / 12-April-2019__

## Main Changes

### First release

First official release for __STM32F756xx/746xx/745xx__ devices

:::

:::
:::

For complete documentation on STM32 Microcontrollers  ,
visit: [[www.st.com/stm32](http://www.st.com/stm32)]{style="font-color: blue;"}
*This release note uses up to date web standards and, for this reason, should not be opened with Internet
Explorer but preferably with popular browsers such as Google Chrome, Mozilla Firefox, Opera or Microsoft
Edge.*

repository: BisonLeo/USBMicST

repo_name: BisonLeo/USBMicST


text:
# Docker & PHP 101

![First Slide](https://dirtybirdnj.github.io/docker-php-101/img/first-slide.png)

A breakdown of how to use Docker to run PHP code and applications. This overview covers the different commands and concepts needed to work with almost any dockerized application reguardless of language.

## Table of contents

- Virtualization - What where & why?
- Previous tools
- Docker alternatives
- What is Docker
- Build Process / Dockerfile / Images
- Docker Hub / AWS ECR
- Running Containers
- docker-compose for multiple services

#### More reading
Links from talk go here

Mat Gilbert 2019

license: MIT

branch_name: refs/heads/master

extension: md

gha_language: JavaScript

gha_license_id: MIT

license_type: permissive


text:
# WebPageTest Gatherer

## Overview

For more details on the WebPageTest API, please check out
[the official documentation](https://github.com/WPO-Foundation/webpagetest-docs/blob/master/dev/api.md).

Below is a sample `Test` with `webpagetest` property that defines the
configuration for running a WebPageTest audit.

```
{
  "label": "Example",
  "url": "https://example.com",
  "gatherer": "webpagetest",
  "webpagetest": {
    "settings": {
      "locationId": "Dulles_MotoG",
      "device": "Pixel",
      "connection": "4G",
      "runs": 1,
      "repeatView": true,
      "timeline": true,
      "block": null,
      "script": null
    }
  }
}
```

## Required Environmental Variables

- `GCP_PROJECT_ID` - The project unique ID in the Google Cloud Platform.
- `SERVICE_ACCOUNT_CREDENTIALS` - The path to the Service Account json file.

## Audit Lifecycle

A WebPageTest run may take a few minutes to complete, depending on the parameters
like number of runs, locations, repeat views, etc.

Hence, the auditing model is asynchronous. After executing a `run` action,
WebPageTeset won't return the metric values immediately. Instead, it is required
to execute a `retrieve` action to retrieve the metric values.

The following CLI example explains the two-steps approach:

```
# Run tests
./awp run --tests=examples/tests.json --results=output/results.json

# Retrieve results
./awp retrieve --tests=examples/tests.json --results=output/results.json
```

## Configuration details

- `settings` <Object>: The settings is an object that defines a list of parameters for
running a WebPageTest audit. See the following parameters for details.
- `settings.locationId` <string>: Location ID, used as the `location`
parameter in the [WebPageTest RESTful API](https://github.com/WPO-Foundation/webpagetest-docs/blob/master/dev/api.md#parameters).
- `settings.connection` <string>: Network connection speed, like `3G` or `4G`.
This will be used as the `connectivity` parameter in [WebPageTest RESTful API](https://github.com/WPO-Foundation/webpagetest-docs/blob/master/dev/api.md#parameters).
- `settings.device` <string>: Mobile device name, as the `mobileDevice` parameter in
[WebPageTest RESTful API](https://github.com/WPO-Foundation/webpagetest-docs/blob/master/dev/api.md#parameters).
- `settings.runs` <number>: Number of runs per audit, the same as in `runs` parameter
in the [WebPageTest RESTful API](https://github.com/WPO-Foundation/webpagetest-docs/blob/master/dev/api.md#parameters).
- `settings.repeatView` <boolean>: Whether to include repeat view test in the
WebPageTest report. This will be used for `fvonly` in the
[WebPageTest RESTful API](https://github.com/WPO-Foundation/webpagetest-docs/blob/master/dev/api.md#parameters). Please note that if `repeatView`
is set to true, `fvonly` will be 0, and vise versa.
- `settings.timeline` <boolean>: Whether to include the timeline view in the
WebPageTest report, used as `timeline` in [WebPageTest RESTful API](https://github.com/WPO-Foundation/webpagetest-docs/blob/master/dev/api.md#parameters).
- `settings.block` <string>: Whether to block specific assets from network
requests. This will be used as `block` in [WebPageTest RESTful API](https://github.com/WPO-Foundation/webpagetest-docs/blob/master/dev/api.md#parameters).
- `settings.script` <string>: Whether to run custom steps in a WebPageTest audit.
This will be used as `script` in [WebPageTest RESTful API](https://github.com/WPO-Foundation/webpagetest-docs/blob/master/dev/api.md#parameters).

## Run a Test

After running, the `webpagetest` object in a `Result` object will
contain the `metadata` object and its corresponding values, like below:

```
{
  "label": "Example",
  "url": "https://example.com",
  "status": "Retrieved",
  "webpagetest": {
    "settings": {
      "locationId": "Dulles_MotoG",
      "device": "Pixel",
      "connection": "4G",
      "runs": 1,
      "repeatView": true,
      "timeline": true,
      "block": null,
      "script": null
    },
    "metadata": {
      "testId": "someTestId",
      "ownerKey": "someKey",
      "jsonUrl": "https://webpagetest.org/jsonResult.php?test=someTestId",
      "xmlUrl": "https://webpagetest.org/xmlResult/someTestId/",
      "userUrl": "https://webpagetest.org/result/someTestId/",
      "summaryCSV": "https://webpagetest.org/result/someTestId/page_data.csv",
      "detailCSV": "https://webpagetest.org/result/someTestId/requests.csv"
    }
  }
}
```

These metadata will be used to retrieve metrics.

## Retrieve Metrics

After retrieving, the `webpagetest` object in a `Test` object will
contain the `metrics` object and its corresponding values, like below:

```
{
  "label": "Example",
  "url": "https://example.com",
  "webpagetest": {
    "settings": {
      "locationId": "Dulles_MotoG",
      "device": "Pixel",
      "connection": "4G",
      "runs": 1,
      "repeatView": true,
      "timeline": true,
      "block": null,
      "script": null
    },
    "metadata": {
      "testId": "someTestId",
      "ownerKey": "someKey",
      "jsonUrl": "https://webpagetest.org/jsonResult.php?test=someTestId",
      "xmlUrl": "https://webpagetest.org/xmlResult/someTestId/",
      "userUrl": "https://webpagetest.org/result/someTestId/",
      "summaryCSV": "https://webpagetest.org/result/someTestId/page_data.csv",
      "detailCSV": "https://webpagetest.org/result/someTestId/requests.csv"
    },
    "metrics": {
      "lighthouse": {
        "Performance": 0.97,
        "ProgressiveWebApp": 0.38,
        "FirstContentfulPaint": 1805.008,
        ...
      },
      "FirstContentfulPaint": 692,
      "SpeedIndex": 702,
      ...
    }
  }
}
```

Since the WebPageTest provides both built-in metrics as well as Lighthouse metrics,
there will be a `lighthouse` property containing the Lighthouse metrics.

repository: GoogleChromeLabs/AutoWebPerf

branch_name: refs/heads/stable

repo_name: GoogleChromeLabs/AutoWebPerf


text:
# My Singapore Polytechnic(SP) assignments/projects

Hi again, this repo is too mainly host my school projects on Github puclicly.
I usually only upload my projects here after the semester ends, so I guess just look out for semesterly updates.

If you are reading this and from SP, welcome to my repo, feel free to use my projects as references. (Don't copy them please :D)

The modules are listed with their acronym first then their subject code beside them.

Example:
`FOC_ST2413` → `FOC` is for `Fundementals of Computing`, `ST2413` is the subject code.

To find out more about the projects/assignemts for the module you can look into the folders, they would have a structure of,
```bash
module folder
├── CAx
│   └── project/assignment folder
└── README.md
```

# LICENSE
[MIT](LICENSE)

gha_language: Jupyter Notebook


text:
# LEMP, NodeJS and Jekyll Vagrant machine.

__Notice__: This vagrant box and it's bootstrap script are obsolete. Check the new one based on Ubuntu here:
https://github.com/drvy/drvys-box

## Introduction
Basic Vagrant Setup with a bootstrap script for a LEMP (Ningx PHP7, MariaDB) stack, Jekyll, NodeJS, Ruby and Composer. Makes use of the 64 bit version of Debian Jessie box provided by Vagrant itself. Automates the setup and initial configuration of the packages.

It's a custom machine I use in my projects.

## Requirements
* [VirtualBox](https://www.virtualbox.org)
* [Vagrant](http://vagrantup.com)
* [Cygwin](https://www.cygwin.com/) or any other ssh-capable terminal shell.
* [Rsync](https://es.wikipedia.org/wiki/Rsync) if you're using a Windows host.

## What is inside.
* Debian Jessie (x64) (`debian/contrib-jessie64`)
* MariaDB (`mariadb-server mariadb-client`)
* Nginx (`nginx`)
* PHP 7 (`php7.0-fpm`)
* Ruby 2.1 (`ruby2.1-dev`)
* NodeJS (`nodejs`)
* github-pages (`github-pages bundler jekyll-paginate`)
* Jekyll (_provided with github-pages_)
* Composer (_lastest version on provision_).

__PHP Extensions__
`php7.0-cli php7.0-curl php7.0-dev php7.0-zip php7.0-gd php7.0-xml php7.0-mysql php7.0-mcrypt php7.0-mbstring php7.0-opcache`

__Other Packages__
`curl zlib1g-dev build-essential`

## Building the machine.
    host $ git clone https://github.com/drvy/dmdev-vagrant.git
    host $ cd dmdev-vagrant
    host $ vagrant up

Once build, log into the machine with:

    host $ vagrant ssh

You can check if everything went well by opening `http://<IP_ADDRESS>` on your host machine.

## Shared (sync) folder
There is a shared folder that points directly to the root directory of the  Nginx site. That is:

    host: dmdev-vagrant/wwww
    guest: /var/www/

### Rsync on Windows

Please notice that some boxes like the one used here, force the sharing method to `rsync`. RSYNC does NOT come by default in Windows environments and you need to install it by yourself before running the box for the first time.

The easiest way to install it is to install the CyGWIN platform. Go to [Cygwin.com](https://www.cygwin.com/), download and run the installer. When it prompts you for packages to install, be sure to select `rsync` and `openssh`.

Also, notice that the GIT installer for Windows although it does include some UNIX tools, does NOT provide rsync therefore you should use the CyGWIN Terminal to provision and run your Vagrant box.

## Database
The default MariaDB user is `root`. The default password for `root` is `toor`.
You can change that by changing the arguments for the provisioning inside the `Vagrantfile`.

__* Notice:__ As this is pretended to be a development machine, MariaDB installation is NOT secured.

### Access
You can access the database as normal. PHPMyAdmin is NOT available. You can use any external program for such task by providing the default params. Recommendend and tested programs: [Navicat](https://www.navicat.com/), [HeidiSQL](https://www.heidisql.com/) and [MySQL Workbench](https://www.mysql.com/products/workbench/).

A setup example for _Navicat_ would be:
![Navicat Config](https://i.imgur.com/QuVmJoQ.gif)

Vagrant is instructed not to generate a random key file, so your __Private Key__ will be inside the Vagrant folder named as `insecure_private_key`.

## Ports
- The only port fowarded is the default SSH (22), and its done automatically by Vagrant.
- GitHub-Pages or Jekyll use by default the port 4000.
- MariaDB uses the default port (3306)

## Serving (and testing) with Jekyll.
There are some problems forwarding the connections between the Jekyll server  and the guest/host. Also, you need to enable force polling so Jekyll can  correctly watch and update the site on the go. If you want to serve a Jekyll site with auto-rebuild, you should use this command:

    jekyll serve --force_polling --host=<IP_ADDRESS>

If everything builds well, you should be able to access your Jekyll site on your host machine by accessing `http://<IP_ADDRESS>:4000`

## Nginx
The default nginx virtualhost (site) is replaced with a custom one in order to be able to serve PHP files. No big changes. You can check the `bootstrap.sh` file to see what the build looks like.

The default site serves files from `/var/www/`.
The default site logs are in `/var/log/nginx/`.

### SSL.
On provision, the machine will generate a self-signed certificate to enable NGINX SSL (HTTPS). Since the key is self-signed, you will be presented with an alert on any modern browser. Just skip or replace the certificate (`/etc/nginx/conf.d/certs/dmdev.(cert/key)`) with your own.

### `sendfile off;`
Due to a known bug with Virtualbox, the `sendfile` directive is disabled by default after installation. You can change this behavior inside the `Vagrantfile`. However you may experience some annoying behavior like files not updating after a change on the host machine.

## URLs.
This are the default URLs on your host machine:

|   Service    |                                                     URL |
|:------------:|--------------------------------------------------------:|
| HTTP (Nginx) | `http://<IP_ADDRESS>` or `https://<IP_ADDRESS>`       |
| Jekyll       | `http://<IP_ADDRESS>:4000`                             |

## Virtual Machine Management (Vagrant)
These are the basic commands to manage the vagrant machine. If you want to know
more about them, just check the official Vagrant documentation.

|    Action    |                                     Command |
|:------------:|--------------------------------------------:|
| First Start  | `vagrant up --provision`                    |
| Normal Start | `vagrant up`                                |
| Suspend      | `vagrant suspend`                           |
| Resume       | `vagrant resume`                            |
| Shutdown     | `vagrant halt`                              |
| Destroy      | `vagrant destroy`                           |
| Status       | `vagrant status`                            |

## License
    The MIT License (MIT)

    Copyright (c) 2018 Dragomir Yordanov

    Permission is hereby granted, free of charge, to any person obtaining a copy
    of this software and associated documentation files (the "Software"), to deal
    in the Software without restriction, including without limitation the rights
    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    copies of the Software, and to permit persons to whom the Software is
    furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be included in all
    copies or substantial portions of the Software.

     IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
    SOFTWARE.

repository: drvy/dmdev-vagrant

repo_name: drvy/dmdev-vagrant


text:
# Instructions

## Requirements

- Node v14 or higher. Use nvm to manage node installations. Install using:
    ```
    https://github.com/nvm-sh/nvm#install--update-script
    ```

- NPM dependencies:

    ```bash
    npm install
    ```

## Runtime

Check index.js to see port and routes. Command to start the server:

```bash
npm start
```

## Scripts with data samples

POST some SPO2 values

```bash
bash test/post-spo2.sh 97
bash test/post-spo2.sh 98
bash test/post-spo2.sh 99
```

GET the statistics

```bash
 bash test/fetch-stats.sh
```

repository: fjvieira/shift-left-exer

branch_name: refs/heads/main

repo_name: fjvieira/shift-left-exer


text:
#### Component tests using original store
(not suggested)

```js
import { shallowMount } from '@vue/test-utils';
import Home from<EMAIL_ADDRESS>import store from '@/store';

test('snapshot test with default props', () => {
  const wrapper = shallowMount(Home, { store });
  expect(wrapper).toMatchSnapshot();
});
```

https://vue-test-utils.vuejs.org/guides/using-with-vuex.html

After testing our store, we should test components too.

We can shallowMount our component passing the original store,
testing like nothing's happened, but this is not suggested...why?

branch_name: refs/heads/denny


text:
# Icinga2 - Zenduty Integration
Scripts for Icinga2-Zenduty integration

## Setup instructions
1. Install Icinga2 on your system. After this, add an integration on your zenduty account. Not the integration key automatically provided to you.
2. Download the Zenduty-Icinga2  files by following the steps given below:
```
cd /tmp
git clone https://github.com/Zenduty/icinga-zenduty-script.git
cd icinga-zenduty-script
```
3. Open zenduty-icinga2.conf file and enter the integration key provided into the “pager” field.
4. Move the files into their respective folders inside /etc/icinga2/. The zenduty-icinga2.conffile must go to the conf.d folder (or the objects.d folder, whichever exists),
```
mv zenduty-icinga2.conf /etc/icinga2/conf.d/
OR
mv zenduty-icinga2.conf /etc/icinga2/objects.d/
```
and the zenduty-webhook-notification.py file must go to the scripts folder,
```
mv zenduty-webhook-notification.py /etc/icinga2/scripts/
```
5. Make sure ‘icingaadmins’ as a user group exists. Else define it as follows in the users.conf file in conf.d  folder.
```
object UserGroup "icingaadmins" {
display_name = "Icinga 2 Admin Group"
}
```
6. Add the custom attribute use_pagerduty to your configuration’s host and service configuration objects:
```
vars.enable_zenduty = true
```
If you have a large number of such objects, you can just add the above line to the generic-host and generic-service templates in the templates.conf file in the conf.d folder. Then just import this template to your objects.
7. Restart Icinga 2 service
```
/etc/init.d/icinga2 restart
```

repository: AmodhShenoy/icinga-zenduty-script

repo_name: AmodhShenoy/icinga-zenduty-script


text:
https://github.com/intel/multus-cni.git

![multus-cni Logo](https://github.com/Intel-Corp/multus-cni/blob/master/doc/images/Multus.png)

   * [MULTUS CNI plugin](#multus-cni-plugin)
      * [Multi-Homed pod](#multi-homed-pod)
      * [Build](#build)
      * [Work flow](#work-flow)
      * [Usage with Kubernetes CRD/TPR based network objects](#usage-with-kubernetes-crdtpr-based-network-objects)
         * [Creating "Network" resources in Kubernetes](#creating-network-resources-in-kubernetes)
            * [CRD based Network objects](#crd-based-network-objects)
            * [TPR based Network objects(TPR deprecated in Kubernetes 1.7)](#tpr-based-network-objects)
         * [Creating network resources in Kubernetes](#creating-network-resources-in-kubernetes-1)
         * [Configuring Multus to use the kubeconfig](#configuring-multus-to-use-the-kubeconfig)
         * [Configuring Multus to use kubeconfig and a default network](#configuring-multus-to-use-kubeconfig-and-a-default-network)
         * [Configuring Pod to use the CRD/TPR network objects](#configuring-pod-to-use-the-crdtpr-network-objects)
         * [Verifying Pod network interfaces](#verifying-pod-network-interfaces)
      * [Using with Multus conf file](#using-with-multus-conf-file)
      * [Testing Multus CNI](#testing-multus-cni)
         * [Multiple flannel networks](#multiple-flannel-networks)
            * [Configure Kubernetes with CNI](#configure-kubernetes-with-cni)
            * [Launching workloads in Kubernetes](#launching-workloads-in-kubernetes)
      * [Multus additional plugins](#multus-additional-plugins)
      * [NFV based networking in Kubernetes](#nfv-based-networking-in-kubernetes)
      * [Need help](#need-help)
      * [Contacts](#contacts)

# MULTUS CNI plugin
- _Multus_ is a latin word for "Multi"
- As the name suggests, it acts as a Multi plugin in Kubernetes and provides the multiple network interface support in a pod
- Multus supports all [reference plugins](https://github.com/containernetworking/plugins) (eg. [Flannel](https://github.com/containernetworking/plugins/tree/master/plugins/meta/flannel), [DHCP](https://github.com/containernetworking/plugins/tree/master/plugins/ipam/dhcp), [Macvlan](https://github.com/containernetworking/plugins/tree/master/plugins/main/macvlan)) that implement the CNI specification and all 3rd party plugins (eg. [Calico](https://github.com/projectcalico/cni-plugin), [Weave](https://github.com/weaveworks/weave), [Cilium](https://github.com/cilium/cilium), [Contiv](https://github.com/contiv/netplugin)). In addition to it, Multus supports [SRIOV](https://github.com/hustcat/sriov-cni), [SRIOV-DPDK](https://github.com/Intel-Corp/sriov-cni), [OVS-DPDK & VPP](https://github.com/intel/vhost-user-net-plugin) workloads in Kubernetes with both cloud native and NFV based applications in Kubernetes
- It is a contact between the container runtime and other plugins, and it doesn't have any of its own net configuration, it calls other plugins like flannel/calico to do the real net conf job.
- Multus reuses the concept of invoking delegates as used in flannel by grouping multiple plugins into delegates and invoking them in the sequential order of the CNI configuration file provided in json format
- Number of plugins supported is depends on the number of delegates in the configuration file.
- The "masterplugin" is the only net conf option of multus cni, it identifies the primary network. The default route will point to the primary network
- One of the plugin acts as a “Master” plugin and responsible for configuring k8s network with Pod interface “eth0”
- The “Master” plugin also responsible to set the default route for the Pod
- Any subsequent plugin gets Pod interface name as “net0”, “net1”,… “netX and so on
- Multus is one of the projects in the [Baremetal Container Experience kit](https://networkbuilders.intel.com/network-technologies/container-experience-kits).

Please check the [CNI](https://github.com/containernetworking/cni) documentation for more information on container networking.

## Multi-Homed pod

## Build

**This plugin requires Go 1.8 to build.**

Go 1.5 users will need to set GO15VENDOREXPERIMENT=1 to get vendored dependencies. This flag is set by default in 1.6.
```
#./build
```
## Work flow

## Network configuration reference

- name (string, required): the name of the network
- type (string, required): "multus"
- kubeconfig (string, optional): kubeconfig file for the out of cluster communication with kube-apiserver. See the example [kubeconfig](https://github.com/Intel-Corp/multus-cni/blob/master/doc/node-kubeconfig.yaml)
- delegates (([]map,required): number of delegate details in the Multus, ignored in case kubeconfig is added.
- masterplugin (bool,required): master plugin to report back the IP address and DNS to the container

## Usage with Kubernetes CRD/TPR based network objects

Kubelet is responsible for establishing network interfaces for pods; it does this by invoking its configured CNI plugin. When Multus is invoked it retrieves network references from Pod annotation. Multus then uses these network references to get network configurations. Network configurations are defined as Kubernetes Custom Resource Object (CRD). These configurations describe which CNI plugins to invoke and what their configurations are. The order of plugin invocation is important as it identifies the primary plugin. This order is taken from network object references given in a Pod spec.

### Creating "Network" resources in Kubernetes

Multus is compatible to work with both CRD/TPR. Both CRD/TPR based network object api self link is same.

##### **CRD based Network objects**

1. Create a Custom Resource Definition "crdnetwork.yaml" for the network object as shown below:

```
apiVersion: apiextensions.k8s.io/v1beta1
kind: CustomResourceDefinition
metadata:
  # name must match the spec fields below, and be in the form: <plural>.<group>
  name: networks.kubernetes.com
spec:
  # group name to use for REST API: /apis/<group>/<version>
  group: kubernetes.com
  # version name to use for REST API: /apis/<group>/<version>
  version: v1
  # either Namespaced or Cluster
  scope: Namespaced
  names:
    # plural name to be used in the URL: /apis/<group>/<version>/<plural>
    plural: networks
    # singular name to be used as an alias on the CLI and for display
    singular: network
    # kind is normally the CamelCased singular type. Your resource manifests use this.
    kind: Network
    # shortNames allow shorter string to match your resource on the CLI
    shortNames:
    - net
```
2. Run kubectl create command for the Custom Resource Definition
```
# kubectl create -f ./crdnetwork.yaml
customresourcedefinition "network.kubernetes.com" created
```
3. Run kubectl get command to check the Network CRD creation
```
# kubectl get CustomResourceDefinition
NAME                      KIND
networks.kubernetes.com   CustomResourceDefinition.v1beta1.apiextensions.k8s.io
```

4. Save the following YAML to flannel-network.yaml

```
apiVersion: "kubernetes.com/v1"
kind: Network
metadata:
  name: flannel-networkobj
plugin: flannel
args: '[
        {
                "delegate": {
                        "isDefaultGateway": true
                }
        }
]'
```

5. Create the custom resource definition

```
# kubectl create -f customCRD/flannel-network.yaml
network "flannel-networkobj" created
```
```
# kubectl get network
NAME                 KIND                        ARGS                                               PLUGIN
flannel-networkobj   Network.v1.kubernetes.com   [ { "delegate": { "isDefaultGateway": true } } ]   flannel
```

6. Get the custom network object details
```
# kubectl get network flannel-networkobj -o yaml
apiVersion: kubernetes.com/v1
args: '[ { "delegate": { "isDefaultGateway": true } } ]'
kind: Network
metadata:
  clusterName: ""
  creationTimestamp: 2017-07-11T21:46:52Z
  deletionGracePeriodSeconds: null
  deletionTimestamp: null
  name: flannel-networkobj
  namespace: default
  resourceVersion: "6848829"
  selfLink: /apis/kubernetes.com/v1/namespaces/default/networks/flannel-networkobj
  uid: 7311c965-6682-11e7-b0b9-408d5c537d27
plugin: flannel
```

For Kubernetes v1.7 and above use CRD to create network object. For version older than 1.7 use TPR based objects as shown below:

Note: Both TPR and CRD will have same selfLink :

*/apis/kubernetes.com/v1/namespaces/default/networks/*

#### TPR based Network objects

1. Create a Third Party Resource "tprnetwork.yaml" for the network object as shown below:

```
apiVersion: extensions/v1beta1
kind: ThirdPartyResource
metadata:
  name: network.kubernetes.com
description: "A specification of a Network obj in the kubernetes"
versions:
- name: v1
```

2. Run kubectl create command for the Third Party Resource

```
# kubectl create -f ./tprnetwork.yaml
thirdpartyresource "network.kubernetes.com" created
```
3. Run kubectl get command to check the Network TPR creation
```
# kubectl get thirdpartyresource
NAME                     DESCRIPTION                                          VERSION(S)
network.kubernetes.com   A specification of a Network obj in the kubernetes   v1
```
### Creating network resources in Kubernetes

1. After creating CRD/TPR network object you can create network resources in Kubernetes. These network resources may contain additional underlying CNI plugin parameters given in JSON format. In the following example shown below the args field contains parameters that will be passed into “flannel” plugin.

2. Save the following YAML to flannel-network.yaml

```
apiVersion: "kubernetes.com/v1"
kind: Network
metadata:
  name: flannel-conf
plugin: flannel
args: '[
        {
                "delegate": {
                        "isDefaultGateway": true
                }
        }
]'
```
3. Run kubectl create command to create network object
```
# kubectl create -f ./flannel-network.yaml
network "flannel-conf" created
```
4. Show network objects using kubectl:
```
# kubectl get network
NAME                         KIND
flannel-conf                 Network.v1.kubernetes.com
```
5. Show details of the network object:

```
# kubectl get network flannel-conf -o yaml
apiVersion: kubernetes.com/v1
args: '[ { "delegate": { "isDefaultGateway": true } } ]'
kind: Network
metadata:
  creationTimestamp: 2017-06-28T14:20:52Z
  name: flannel-conf
  namespace: default
  resourceVersion: "5422876"
  selfLink: /apis/kubernetes.com/v1/namespaces/default/networks/flannel-conf
  uid: fdcb94a2-5c0c-11e7-bbeb-408d5c537d27
plugin: flannel
```
6. Save the following YAML to sriov-network.yaml to creating sriov network object. ( Refer to [Intel - SR-IOV CNI](https://github.com/Intel-Corp/sriov-cni) or contact @kural in [Intel-Corp Slack](https://intel-corp.herokuapp.com/) for running the DPDK based workloads in Kubernetes)
```
apiVersion: "kubernetes.com/v1"
kind: Network
metadata:
  name: sriov-conf
plugin: sriov
args: '[
       {
                "if0": "enp12s0f1",
                "ipam": {
                        "type": "host-local",
                        "subnet": "<IP_ADDRESS>/24",
                        "rangeStart": "<IP_ADDRESS>",
                        "rangeEnd": "<IP_ADDRESS>",
                        "routes": [
                                { "dst": "<IP_ADDRESS>/0" }
                        ],
                        "gateway": "<IP_ADDRESS>"
                }
        }
]'
```
7. Likewise save the following YAML to sriov-vlanid-l2enable-network.yaml to create another sriov based network object:

```
apiVersion: "kubernetes.com/v1"
kind: Network
metadata:
  name: sriov-vlanid-l2enable-conf
plugin: sriov
args: '[
       {
                "if0": "enp2s0",
                "vlan": 210,
                "if0name": "north",
                "l2enable": true
        }
]'
```
8. Follow step 3 above to create "sriov-vlanid-l2enable-conf" and "sriov-conf" network objects
9. View network objects using kubectl
```
# kubectl get network
NAME                         KIND
flannel-conf                 Network.v1.kubernetes.com
sriov-vlanid-l2enable-conf   Network.v1.kubernetes.com
sriov-conf                   Network.v1.kubernetes.com
```
### Configuring Multus to use the kubeconfig
1. Create a Mutlus CNI configuration file on each Kubernetes node. This file should be created in: /etc/cni/net.d/multus-cni.conf with the content shown below. Use only the absolute path to point to the kubeconfig file (as it may change depending upon your cluster env). We are assuming all CNI plugin binaries are default location (`\opt\cni\bin dir`)
```
{
    "name": "node-cni-network",
    "type": "multus",
    "kubeconfig": "/etc/kubernetes/node-kubeconfig.yaml"
}
```
2. Restart kubelet service
```
# systemctl restart kubelet
```
### Configuring Multus to use kubeconfig and a default network

1. Many users want Kubernetes default networking feature along with network objects. Refer to issues [#14](https://github.com/Intel-Corp/multus-cni/issues/14) & [#17](https://github.com/Intel-Corp/multus-cni/issues/17) for more information. In the following Multus configuration, Weave act as the default network in the absence of network field in the pod metadata annotation.

```
{
    "name": "node-cni-network",
    "type": "multus",
    "kubeconfig": "/etc/kubernetes/node-kubeconfig.yaml",
    "delegates": [{
        "type": "weave-net",
        "hairpinMode": true,
        "masterplugin": true
    }]
}
```
2. Restart kubelet service

```
# systemctl restart kubelet
```

### Configuring Pod to use the CRD/TPR network objects

1. Save the following YAML to pod-multi-network.yaml. In this case flannel-conf network object acts as the primary network.
```
# cat pod-multi-network.yaml
apiVersion: v1
kind: Pod
metadata:
  name: multus-multi-net-poc
  annotations:
    networks: '[
        { "name": "flannel-conf" },
        { "name": "sriov-conf"},
        { "name": "sriov-vlanid-l2enable-conf" }
    ]'
spec:  # specification of the pod's contents
  containers:
  - name: multus-multi-net-poc
    image: "busybox"
    command: ["top"]
    stdin: true
    tty: true
```

2. Create Multiple network based pod from the master node

```
# kubectl create -f ./pod-multi-network.yaml
pod "multus-multi-net-poc" created
```

3. Get the details of the running pod from the master

```
# kubectl get pods
NAME                   READY     STATUS    RESTARTS   AGE
multus-multi-net-poc   1/1       Running   0          30s
```

### Verifying Pod network interfaces

1. Run "ifconfig" command in Pod:
```
# kubectl exec -it multus-multi-net-poc -- ifconfig
eth0      Link encap:Ethernet  HWaddr 06:21:91:2D:74:B9
          inet addr:<IP_ADDRESS>  Bcast:<IP_ADDRESS>  Mask:<IP_ADDRESS>
          inet6 addr: fe80::421:91ff:fe2d:74b9/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1450  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:8 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0
          RX bytes:0 (0.0 B)  TX bytes:648 (648.0 B)

lo        Link encap:Local Loopback
          inet addr:<IP_ADDRESS>  Mask:<IP_ADDRESS>
          inet6 addr: ::1/128 Scope:Host
          UP LOOPBACK RUNNING  MTU:65536  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1
          RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)

net0      Link encap:Ethernet  HWaddr D2:94:98:82:00:00
          inet addr:<IP_ADDRESS>  Bcast:<IP_ADDRESS>  Mask:<IP_ADDRESS>
          inet6 addr: fe80::d094:98ff:fe82:0/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:2 errors:0 dropped:0 overruns:0 frame:0
          TX packets:8 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:120 (120.0 B)  TX bytes:648 (648.0 B)

north     Link encap:Ethernet  HWaddr BE:F2:48:42:83:12
          inet6 addr: fe80::bcf2:48ff:fe42:8312/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:1420 errors:0 dropped:0 overruns:0 frame:0
          TX packets:1276 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:95956 (93.7 KiB)  TX bytes:82200 (80.2 KiB)
```
| Interface name | Description |
| --- | --- |
| lo | loopback |
| eth0@if41 | Flannel network tap interface |
| net0 | VF0 of NIC 1 assigned to the container by [Intel - SR-IOV CNI](https://github.com/Intel-Corp/sriov-cni) plugin |
| north | VF0 of NIC 2 assigned with VLAN ID 210 to the container by SR-IOV CNI plugin |

2. Check the vlan ID of the NIC 2 VFs

```
# ip link show enp2s0
20: enp2s0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP mode DEFAULT group default qlen 1000
    link/ether 24:8a:07:e8:7d:40 brd ff:ff:ff:ff:ff:ff
    vf 0 MAC 00:00:00:00:00:00, vlan 210, spoof checking off, link-state auto
    vf 1 MAC 00:00:00:00:00:00, vlan 4095, spoof checking off, link-state auto
    vf 2 MAC 00:00:00:00:00:00, vlan 4095, spoof checking off, link-state auto
    vf 3 MAC 00:00:00:00:00:00, vlan 4095, spoof checking off, link-state auto
```

## Using with Multus conf file

Given the following network configuration:

```
# tee /etc/cni/net.d/multus-cni.conf <<-'EOF'
{
    "name": "multus-demo-network",
    "type": "multus",
    "delegates": [
        {
                "type": "sriov",
                #part of sriov plugin conf
                "if0": "enp12s0f0",
                "ipam": {
                        "type": "host-local",
                        "subnet": "<IP_ADDRESS>/24",
                        "rangeStart": "<IP_ADDRESS>",
                        "rangeEnd": "<IP_ADDRESS>",
                        "routes": [
                                { "dst": "<IP_ADDRESS>/0" }
                        ],
                        "gateway": "<IP_ADDRESS>"
                }
        },
        {
                "type": "ptp",
                "ipam": {
                        "type": "host-local",
                        "subnet": "<IP_ADDRESS>/24",
                        "rangeStart": "<IP_ADDRESS>",
                        "rangeEnd": "<IP_ADDRESS>",
                        "routes": [
                                { "dst": "<IP_ADDRESS>/0" }
                        ],
                        "gateway": "<IP_ADDRESS>"
                }
        },
        {
                "type": "flannel",
                "masterplugin": true,
                "delegate": {
                        "isDefaultGateway": true
                }
        }
    ]
}
EOF
```

## Testing Multus CNI

### Multiple flannel networks

Github user [YYGCui](https://github.com/YYGCui) has used multiple flannel network to work with Multus CNI plugin. Please refer to this [closed issue](https://github.com/Intel-Corp/multus-cni/issues/7) for ,multiple overlay network support with Multus CNI.

Make sure that the multus, [sriov](https://github.com/Intel-Corp/sriov-cni), [flannel](https://github.com/containernetworking/cni/blob/master/Documentation/flannel.md), and [ptp](https://github.com/containernetworking/cni/blob/master/Documentation/ptp.md) binaries are in the /opt/cni/bin directories and follow the steps as mentioned in the [CNI](https://github.com/containernetworking/cni/#running-a-docker-container-with-network-namespace-set-up-by-cni-plugins)

#### Configure Kubernetes with CNI
Kubelet must be configured to run with the CNI network plugin. Edit /etc/kubernetes/kubelet file and add "--network-plugin=cni" flags in KUBELET\_OPTS as shown below:

```
KUBELET_OPTS="...
--network-plugin-dir=/etc/cni/net.d
--network-plugin=cni
"
```
Refer to the Kubernetes User Guide and network plugin for more information.
- [Single Node](https://kubernetes.io/docs/getting-started-guides/fedora/fedora_manual_config/)
- [Multi Node](https://kubernetes.io/docs/getting-started-guides/fedora/flannel_multi_node_cluster/)
- [Network plugin](https://kubernetes.io/docs/admin/network-plugins/)

Restart kubelet:
```
# systemctl restart kubelet.service
```
#### Launching workloads in Kubernetes

With Multus CNI configured as described in sections above each workload launched via a Kubernetes Pod will have multiple network interfacesLaunch the workload using yaml file in the kubernetes master, with above configuration in the multus CNI, each pod should have multiple interfaces.

Note: To verify whether Multus CNI plugin is working correctly, create a pod containing one "busybox" container and execute "ip link" command to check if interfaces management follows configuration.

1. Create "multus-test.yaml" file containing below configuration. Created pod will consist of one "busybox" container running "top" command.

```
apiVersion: v1
kind: Pod
metadata:
  name: multus-test
spec:  # specification of the pod's contents
  restartPolicy: Never
  containers:
  - name: test1
    image: "busybox"
    command: ["top"]
    stdin: true
    tty: true

```
2. Create pod using command:

```
# kubectl create -f multus-test.yaml
pod "multus-test" created
```
3. Run "ip link" command inside the container:

```
# 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue qlen 1
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
3: eth0@if41: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue
    link/ether 26:52:6b:d8:44:2d brd ff:ff:ff:ff:ff:ff
20: net0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq qlen 1000
    link/ether f6:fb:21:4f:1d:63 brd ff:ff:ff:ff:ff:ff
21: net1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq qlen 1000
    link/ether 76:13:b1:60:00:00 brd ff:ff:ff:ff:ff:ff
```

| Interface name | Description |
| --- | --- |
| lo | loopback |
| eth0@if41 | Flannel network tap interface |
| net0 | VF assigned to the container by [SR-IOV CNI](https://github.com/Intel-Corp/sriov-cni) plugin |
| net1 | ptp localhost interface |

## Multus additional plugins

- [DPDK-SRIOV CNI](https://github.com/Intel-Corp/sriov-cni)
- [Vhostuser CNI](https://github.com/intel/vhost-user-net-plugin) - a Dataplane network plugin - Supports OVS-DPDK & VPP
- [Bond CNI](https://github.com/Intel-Corp/bond-cni) - For fail-over and high availability of networking

## NFV based networking in Kubernetes

- KubeCon workshop on ["Enabling NFV features in Kubernetes"](https://kccncna17.sched.com/event/Cvnw/enabling-nfv-features-in-kubernetes-hosted-by-kuralamudhan-ramakrishnan-ivan-coughlan-intel) presentation [slide deck](https://www.slideshare.net/KuralamudhanRamakris/enabling-nfv-features-in-kubernetes-83923352)
- Feature brief
  - [Multiple Network Interface Support in Kubernetes](https://builders.intel.com/docs/networkbuilders/multiple-network-interfaces-support-in-kubernetes-feature-brief.pdf)
  - [Enhanced Platform Awareness in Kubernetes](https://builders.intel.com/docs/networkbuilders/enhanced-platform-awareness-feature-brief.pdf)
- Application note
  - [Multiple Network Interfaces in Kubernetes and Container Bare Metal](https://builders.intel.com/docs/networkbuilders/multiple-network-interfaces-in-kubernetes-application-note.pdf)
  - [Enhanced Platform Awareness Features in Kubernetes](https://builders.intel.com/docs/networkbuilders/enhanced-platform-awareness-in-kubernetes-application-note.pdf)
- White paper
  - [Enabling New Features with Kubernetes for NFV](https://builders.intel.com/docs/networkbuilders/enabling_new_features_in_kubernetes_for_NFV.pdf)
- Multus's related project github pages
  - [Multus](https://github.com/Intel-Corp/multus-cni)
  - [SRIOV - DPDK CNI](https://github.com/Intel-Corp/sriov-cni)
  - [Vhostuser - VPP & OVS - DPDK CNI](https://github.com/intel/vhost-user-net-plugin)
  - [Bond CNI](https://github.com/Intel-Corp/bond-cni)
  - [Node Feature Discovery](https://github.com/kubernetes-incubator/node-feature-discovery)
  - [CPU Manager for Kubernetes](https://github.com/Intel-Corp/CPU-Manager-for-Kubernetes)

## Need help

- Read [Containers Experience Kits](https://networkbuilders.intel.com/network-technologies/container-experience-kits)
- Try our container exp kit demo - KubeCon workshop on [Enabling NFV Features in Kubernetes](https://github.com/intel/container-experience-kits-demo-area/)
- Join us on [#intel-sddsg-slack](https://intel-corp.herokuapp.com/) slack channel and ask question in [#general-discussion](https://intel-corp-team.slack.com/messages/C4C5RSEER)
- You can also<EMAIL_ADDRESS>us
- Feel free to [submit](https://github.com/Intel-Corp/multus-cni/issues/new) an issue

Please fill in the Questions/feedback - [google-form](https://goo.gl/forms/upBWyGs8Wmq69IEi2)!
## Contacts
For any questions about Multus CNI, please reach out on github issue or feel free to contact the developer @kural in our [Intel-Corp Slack](https://intel-corp.herokuapp.com/)

repository: todaygood/container-lab

repo_name: todaygood/container-lab


text:
# QMetaObject crate for Rust

[![Crates.io](https://img.shields.io/crates/v/qmetaobject.svg)](https://crates.io/crates/qmetaobject)
[![Documentation](https://docs.rs/qmetaobject/badge.svg)](https://docs.rs/qmetaobject/)

A framework empowering everyone to create Qt/QML applications with Rust.
It does so by building `QMetaObject`s at compile time, registering QML types (optionally via exposing `QQmlExtensionPlugin`s) and providing idiomatic wrappers.

## Objectives

 - Rust procedural macro (custom derive) to generate a `QMetaObject` at compile time.
 - Bindings for the main Qt types using the `cpp!` macro from the [`cpp`](https://crates.io/crates/cpp) crate.
 - Users of this crate should not require to type any line of C++ or use another build system beyond cargo.
 - Performance: Avoid any unnecessary conversion or heap allocation.

Presentation Blog Post: https://woboq.com/blog/qmetaobject-from-rust.html

## Overview

```rust
use cstr::cstr;
use qmetaobject::prelude::*;

// The `QObject` custom derive macro allows to expose a class to Qt and QML
#[derive(QObject, Default)]
struct Greeter {
    // Specify the base class with the qt_base_class macro
    base: qt_base_class!(trait QObject),
    // Declare `name` as a property usable from Qt
    name: qt_property!(QString; NOTIFY name_changed),
    // Declare a signal
    name_changed: qt_signal!(),
    // And even a slot
    compute_greetings: qt_method!(fn compute_greetings(&self, verb: String) -> QString {
        format!("{} {}", verb, self.name.to_string()).into()
    })
}

fn main() {
    // Register the `Greeter` struct to QML
    qml_register_type::<Greeter>(cstr!("Greeter"), 1, 0, cstr!("Greeter"));
    // Create a QML engine from rust
    let mut engine = QmlEngine::new();
    // (Here the QML code is inline, but one can also load from a file)
    engine.load_data(r#"
        import QtQuick 2.6
        import QtQuick.Window 2.0
        // Import our Rust classes
        import Greeter 1.0

        Window {
            visible: true
            // Instantiate the rust struct
            Greeter {
                id: greeter;
                // Set a property
                name: "World"
            }
            Text {
                anchors.centerIn: parent
                // Call a method
                text: greeter.compute_greetings("hello")
            }
        }
    "#.into());
    engine.exec();
}
```

## Features

 - Create object inheriting from QObject, QQuickItem, QAbstractListModel, QQmlExtensionPlugin, ...
 - Export Qt properties, signals, methods, ...
 - Also support `#[derive(QGadget)]` (same as Q_GADGET)
 - Create Qt plugin (see examples/qmlextensionplugins)
 - Partial scene graph support

Requires Qt >= 5.8

## Cargo features

Cargo provides a way to enable (or disable default) optional [features](https://doc.rust-lang.org/cargo/reference/features.html).

### `log`

By default, Qt's logging system is not initialized, and messages from e.g. QML's `console.log` don't go anywhere.
The "log" feature enables integration with [`log`](https://crates.io/crates/log) crate, the Rust logging facade.

The feature is enabled by default. To activate it, execute the following code as early as possible in `main()`:

```rust
fn main() {
    qmetaobject::log::init_qt_to_rust();
    // don't forget to set up env_logger or any other logging backend.
}
```

### `chrono_qdatetime`

Enables interoperability of `QDate` and `QTime` with Rust [`chrono`](https://crates.io/crates/chrono) package.

This feature is disabled by default.

### `webengine`

Enables `QtWebEngine` functionality. For more details see the [example](./examples/webengine).

This feature is disabled by default.

## What if a wrapper for the Qt C++ API is missing?

It is quite likely that you would like to call a particular Qt function which
is not wrapped by this crate.

In this case, it is always possible to access C++ directly from your rust code
using the `cpp!` macro.

We strive to increase coverage of wrapped API, so whenever there is something
you need but currently missing, you are welcome to open a feature request on
GitHub issues or send a Pull Request right away.

### Tutorial: Adding Rust wrappers for Qt C++ API

This section teaches how to make your own crate with new Qt wrappers, and walk
through a Graph example provided with this repository.

First things first, set up your _Cargo.toml_ and _build.rs_:

1. Add `qttypes` to dependencies.
   Likely, you would just stick to recent versions published on [crates.io](versions).
   ```toml
   [dependencies]
   qttypes = { version = "0.2", features = [ "qtquick" ] }
   ```
   Add more Qt modules you need to the features array.
   Refer to [qttypes crate documentation](docs.qttypes) for a full list of supported modules.
   <br/>
   If you _absolutely need_ latest unreleased changes, use this instead of `version = "..."`:
    * `path = "../path/to/qmetaobject-rs/qttypes"` or
    * `git = "https://github.com/woboq/qmetaobject-rs"`

2. Add `cpp` to dependencies and `cpp_build` to build-dependencies.
   You can find up-to-date instructions on [`cpp` documentation](https://docs.rs/cpp) page.
   ```toml
   [dependencies]
   cpp = "0.5"

   [build-dependencies]
   cpp_build = "0.5"
   ```

3. Copy _build.rs_ script from [_qmetaobject/build.rs_](./qmetaobject/build.rs).
   It will run `cpp_build` against you package, using environment provided by
   [_qttypes/build.rs_](./qttypes/build.rs).

Now, every time you build your package, content of `cpp!` macros will be
collected in one big C++ file and compiled into a static library which will
later be linked into a final binary. You can find this _cpp_closures.cpp_
file buried inside Cargo target directory. Understanding its content might be
useful for troubleshooting.

There are two forms of `cpp!` macro.

* The one with double curly `{{` braces `}}` appends its content verbatim to
  the C++ file. Use it to `#include` headers, define C++ structs & classes etc.

* The other one is for calling expressions at runtime. It is usually written
  with `(` parenthesis `)`, it takes `[` arguments `]` list and requires an
  `unsafe` marker (either surrounding block or as a first keyword inside).

Order of macros invocations is preserved on a per-file (Rust module) basis;
but processing order of files is not guaranteed by the order of `mod`
declarations. So don't assume visibility — make sure to `#include` everything
needed on top of every Rust module.

Check out [documentation of `cpp`](https://docs.rs/cpp) to read more about how
it works internally.

Now that we are all set, let's take a look at the Graph example's code. It is
located in [_examples/graph_](./examples/graph) directory.

Before adding wrappers, we put relevant `#include` lines inside a `{{` double
curly braced `}}` macro:

```rust
cpp! {{
    #include <QtQuick/QQuickItem>
}}
```

If you need to include you own local C++ headers, you can do that too! Check
out how main qmetaobject crate includes _qmetaobject_rust.hpp_ header in
every Rust module that needs it.

Next, we declare a custom QObject, just like in the [overview](#overview), but
this time it derives from `QQuickItem`. Despite its name, `#[derive(QObject)]`
proc-macro can work with more than one base class, as long as it is properly
wrapped and implements the [`QObject`](trait.QObject) trait.

```rust
#[derive(Default, QObject)]
struct Graph {
    base: qt_base_class!(trait QQuickItem),

    // ...
}
```

We wish to call [`QQuickItem::setFlag`] method which is currently not
exposed in the qmetaobject-rs API, so let's call it directly:

```rust
impl Graph {
    fn appendSample(&mut self, value: f64) {
        // ...
        let obj = self.get_cpp_object();
        cpp!(unsafe [obj as "QQuickItem *"] {
            obj->setFlag(QQuickItem::ItemHasContents);
        });
        // ...
    }
}
```

Alternatively, we could add a proper method wrapper, and call it without `unsafe`:

```rust
#[repr(C)]
enum QQuickItemFlag {
    ItemClipsChildrenToShape = 0x01,
    ItemAcceptsInputMethod = 0x02,
    ItemIsFocusScope = 0x04,
    ItemHasContents = 0x08,
    ItemAcceptsDrops = 0x10,
}

impl Graph {
    fn set_flag(&mut self, flag: QQuickItemFlag) {
        let obj = self.get_cpp_object();
        assert!(!obj.is_null());
        cpp!(unsafe [obj as "QQuickItem *", flag as "QQuickItem::Flag"] {
            obj->setFlag(flag);
        });
    }

    fn appendSample(&mut self, value: f64) {
        // ...
        self.set_flag(QQuickItemFlag::ItemHasContents);
        // ...
    }
}
```

Note that C++ method takes optional second argument, but since optional
arguments are not supported by Rust nor by FFI glue, it is always left out
(and defaults to `true`) in this case. To improve on this situation, we could
have added second required argument to Rust function, or implement
two "overloads" with slightly different names, e.g. `set_flag(Flag, bool)` &
`set_flag_on(Flag)` or `enable_flag(Flag)` etc.

Assert for not-null should not be needed if object is guaranteed to be
properly instantiated and initialized before usage. This applies to the
following situations:

- Call [`QObject::cpp_construct()`] directly and store the result in immovable
  memory location;

- Construct [`QObjectPinned`] instance: any access to pinned object or
  conversion to [`QVariant`] ensures creation of C++ object;

- Instantiate object as a QML component. They are always properly
  default-initialized by a QML engine before setting any properties or
  calling any signals/slots.

And that's it! You have just implemented a new wrapper for a Qt C++ class
method. Now send us a Pull Request. 🙂

[versions]: https://crates.io/crates/qmetaobject/versions
[trait.QObject]: https://docs.rs/qmetaobject/latest/qmetaobject/trait.QObject.html
[`QQuickItem::setFlag`]: https://doc.qt.io/qt-5/qquickitem.html#setFlag
[`QObject::cpp_construct()`]: https://docs.rs/qmetaobject/latest/qmetaobject/trait.QObject.html#tymethod.cpp_construct
[`QObjectPinned`]: https://docs.rs/qmetaobject/latest/qmetaobject/struct.QObjectPinned.html
[`QVariant`]: https://docs.rs/qmetaobject/latest/qmetaobject/struct.QVariant.html
[docs.qttypes]: https://docs.rs/qttypes/latest/qttypes/#cargo-features

## Comparison with other projects

This crate objective is to make idiomatic Rust bindings for QML (and only QML, no QWidgets or other
non-graphical Qt API) in a way that doesn't need you to know or use C++ and other build system.
This crates is the best achieving this.

* **[CXX-Qt](https://github.com/KDAB/cxx-qt/)** still makes you to write a bit of boiler-plate code
  in C++ and use extra build step to compile the C++.
  CXX-Qt is ideal to bring some Rust in an existing C++ project. But less so when you just want to
  make an UI for a Rust-only application.

  The CXX-Qt is also  more recent that this crate and make use of Rust features such as attribute
  macro, that did not  exist when the qmetaobject crate was designed.
  (Only derive procedural macro were available in stable rust rust at the time)

* Similarly, the **[Rust Qt Binding Generator](https://invent.kde.org/sdk/rust-qt-binding-generator)**
  is another project that helps to integrate Rust logic in an existing C++/Qt project. This was also
  created before rust had procedural macros, so it uses an external .json file to generate C++ and
  Rust code.

* There exist also a bunch of older crates that tries to provide Rust binding around the Qt C++ API.
  Often automatically generated, these bindings are not idiomatic Rust, require unsafe code to use,
  and are not maintained anymore.

* **[Slint](https://slint-ui.com)** is a project created by the same author of this crate.
  It is not a QML or Qt binding at all, but rather a new language similar to QML, entirely
  implemented in Rust.
  It has the same goal as providing a new to add a UI to a Rust project with idiomatic Rust API,
  but instead of using QML for the UI, it uses its own language.

repository: woboq/qmetaobject-rs

gha_language: Rust

repo_name: woboq/qmetaobject-rs


text:
# Images

## Placing images

There is some limited support for placing PNG images on the drawing. First, load a PNG image using `readpng(filename)`.

Then use `placeimage()` to place it by its top left corner at point `x/y` or `pt`. Access the image's dimensions with `.width` and `.height`.

```@example
using Luxor # hide
Drawing(600, 350, "assets/figures/images.png") # hide
origin() # hide
background("grey40") # hide
img = readpng("assets/figures/julia-logo-mask.png")
w = img.width
h = img.height
axes()
scale(0.3, 0.3)
rotate(pi/4)
placeimage(img, -w/2, -h/2, .5)
sethue("red")
circle(-w/2, -h/2, 15, :fill)
finish() # hide
nothing # hide
```
!["Images"](assets/figures/images.png)

```@docs
readpng
placeimage
```

## Clipping images

You can clip images. The following script repeatedly places the image using a circle to define a clipping path:

!["Images"](assets/figures/test-image.png)

```julia
using Luxor

width, height = 4000, 4000
margin = 500

fname = "/tmp/test-image.pdf"
Drawing(width, height, fname)
origin()
background("grey25")

setline(5)
sethue("green")

image = readpng(dirname(@__FILE__) * "assets/figures/julia-logo-mask.png")

w = image.width
h = image.height

pagetiles = Tiler(width, height, 7, 9)
tw = pagetiles.tilewidth/2
for (pos, n) in pagetiles
    circle(pos, tw, :stroke)
    circle(pos, tw, :clip)
    gsave()
    translate(pos)
    scale(.95, .95)
    rotate(rand(0.0:pi/8:2pi))
    placeimage(image, O, centered=true)
    grestore()
    clipreset()
end

finish()
```

## Transforming images

You can transform images by setting the current matrix, either with `scale()` and `rotate()` and similar, or by modifying it directly. This code skews the image and scales and rotates it in a circle:

```@example
using Luxor # hide
Drawing(600, 400, "assets/figures/transform-images.png") # hide
origin() # hide
img = readpng("assets/figures/clipping-tests.png")
w = img.width
h = img.height
for theta in 0:pi/6:2pi
    gsave()
        scale(.5, .5)
        rotate(theta)
        transform([1, 0, -pi/4, 1, 250, 0])
        placeimage(img, -w/2, -h/2, .75)
    grestore()
end

finish() # hide
nothing # hide
```

![transforming images](assets/figures/transform-images.png)

## Drawing on images

You sometimes want to draw over images, for example to annotate them with text or vector graphics. The things to be aware of are mostly to do with coordinates and transforms.

In this example, we'll annotate a PNG file with some text and graphics.

```@example
using Luxor # hide

image = readpng("assets/figures/julia-logo-mask.png")

w = image.width
h = image.height

# create a drawing surface of the same size

fname = "assets/figures/drawing_on_images.png"
Drawing(w, h, fname)

# place the image on the Drawing - it's positioned by its top/left corner

placeimage(image, 0, 0)

# now you can annotate the image. The (0/0) is at the top left.

sethue("red")
fontsize(20)
circle(5, 5, 2, :fill)
text("(5/5)", Point(25, 25), halign=:center)

arrow(Point(w/2, 50), Point(0, 50))
arrow(Point(w/2, 50), Point(w, 50))
text("width $w", Point(w/2, 70), halign=:center)

# to divide up the image into rectangular areas, temporarily position the axes at the center:

gsave()
setline(0.2)
sethue("green")
fontsize(12)
translate(w/2, h/2)
tiles = Tiler(w, h, 16, 10, margin=0)
for (pos, n) in tiles
    box(pos, tiles.tilewidth, tiles.tileheight, :stroke)
    text(string(n), pos, halign=:center)
end
grestore()

# If you want coordinates to be relative to the bottom left corner of the image, transform:

translate(0, h)

# and reflect in the x-axis

transform([1 0 0 -1 0 0])

# now 0/0 is at the bottom left corner, and 100/100 is up and to the right.

sethue("blue")
arrow(O, Point(100, 100))

# However, don't use text while flipped, because it's reversed:

text("I'm in reverse!", w/2, h/2)

finish() # hide
nothing # hide
```

![drawing on images](assets/figures/drawing_on_images.png)

## Image compositing

You should be using [Images.jl](https://github.com/JuliaImages) for most tasks involving image editing. But if you just need to composite images together, you can use the blending modes provided by `setmode()`.

```@example
using Luxor # hide
Drawing(600, 400, "assets/figures/image-compositing.png") # hide
origin() # hide
img = readpng("assets/figures/textcurvecenteredexample.png")
w = img.width
h = img.height

placeimage(img, -w/2, -h/2, .5)
setmode("saturate")
translate(50, 0)
placeimage(img, -w/2, -h/2, .5)

finish() # hide
nothing # hide
```

![transforming images](assets/figures/image-compositing.png)


text:
# ARCHIVED

I don't have the time or interest to continue working on this project, so I've
marked the repository as read only.

# Online Reversi

A simple web app for playing the game Reversi online.

## Technology

* Node.js
* MySQL
* HTML/CSS/JS

## Intended Features

* Host a game, get unique link to send to your friends
* Join an existing game from a link
* Close the page and return to it later without losing the game state
* Prevent cheating with server-side checks

## How to run:

```
$ cp connection.example.js connection.js
```

Then edit `connection.js` so it has the real database credentials.

```
$ npm install
$ npm start
```

## Testing

We use [mocha](https://mochajs.org/) for testing. Put unit tests in the `test`
folder, and use `npm test` to run them.

repository: jojonium/online-reversi

repo_name: jojonium/online-reversi


text:
---
layout: post
title: "Segmenting Brain Tumors with Symmetry"
date: 2017-11-17 17:22:30
categories: arXiv_CV
tags: arXiv_CV Segmentation Attention
author: Hejia Zhang, Xia Zhu, Theodore L. Willke
mathjax: true
---

* content
{:toc}

##### Abstract
We explore encoding brain symmetry into a neural network for a brain tumor segmentation task. A healthy human brain is symmetric at a high level of abstraction, and the high-level asymmetric parts are more likely to be tumor regions. Paying more attention to asymmetries has the potential to boost the performance in brain tumor segmentation. We propose a method to encode brain symmetry into existing neural networks and apply the method to a state-of-the-art neural network for medical imaging segmentation. We evaluate our symmetry-encoded network on the dataset from a brain tumor segmentation challenge and verify that the new model extracts information in the training images more efficiently than the original model.

##### Abstract (translated by Google)
我们探索编码大脑对称性到一个神经网络的脑肿瘤分割任务。健康的人类大脑在高度抽象层次上是对称的，而高层次的不对称部分更可能是肿瘤区域。更多关注不对称性有可能提高脑肿瘤分割的表现。我们提出了一个方法来编码大脑对称性到现有的神经网络，并应用该方法的国家的最先进的神经网络医学成像分割。我们评估我们对脑肿瘤分割挑战数据集上的对称编码网络，并验证新模型比原始模型更有效地提取训练图像中的信息。

##### URL
[https://arxiv.org/abs/1711.06636](https://arxiv.org/abs/1711.06636)

##### PDF
[https://arxiv.org/pdf/1711.06636](https://arxiv.org/pdf/1711.06636)


text:
---
layout: post
title:  Tech Slam
subtitle: The Floor is Yours
date:   2018-12-13 19:00:00
categories: Group
tags: [Other/Tech Slams]
bigimg: /img/slam.jpg
---

Tonight, we go back to the Slam concept, where everyone in attendance gets a chance to make 5-7 minute short introductions/presentations on something in the technology field they have come across, are curious about, don’t quite get, a book they have read or a video they have seen--anything they think might interest the Forum. It is always a lot of fun, and the most unusual things tend to come up. Not to be missed.

So come and be inspired - and have fun!

Presenter: anyone who wants to share something

### Follow-Up

Pamela presented “Project Mosul”, an effort to restore invaluable cultural artefact in digital format and 3D printed versions. Visit [http://rekrei.org](http://rekrei.org) and watch a PBS video on [“digital archaeology”](https://www.pbs.org/newshour/show/destroyed-isis-artifacts-may-find-new-life-3d-reconstruction).

Craig reminded the participants of the advantages of using the following apps:
* [LastPass](https://www.lastpass.com/) (similar to [1Password](https://1password.com))
* [Curiosity Stream](https://curiositystream.com)
* [Dropbox](https://www.dropbox.com) (file management)
* [SnagIt](https://www.techsmith.com/store/snagit)
* [Google Photos](https://photos.google.com) (similar to Amazon Prime photo storage)

Craig also showed and explained the [TILE device](https://www.thetileapp.com) (for tracking of ‘lost’ items).

Gary mentioned

* the technology behind the new [“Sun In The Box”](http://news.mit.edu/2018/liquid-silicon-store-renewable-energy-1206) energy storage system
* the [Electronic Pill](http://news.mit.edu/2018/ingestible-pill-controlled-wirelessly-bluetooth-1213) that can record and transmit diagnostic information from your body to your phone.

Mark D explained the idea behind “get a container” for living/housing (see
[Our Desert Nest](http://ourdesertnest.com), a container home being built in Cave Creek).
If you want one for your mother-in-law, see
[10 Things You Need To Know BEFORE You Buy A Shipping Container](https://offgridworld.com/10-things-you-need-to-know-before-you-buy-a-container/).

Also, Mark explained progress in the field of [Wireless Power Transfer](https://en.wikipedia.org/wiki/Wireless_power_transfer) (WPT) and mentioned that:
- Qi controllers built into most WPT systems
- More and more silicon companies (Intel, Analog Devices) are announcing products.
Different systems will be shown at CES2018.

Torben showed MIT’s [Solid State Airplane](/assets/present/2018/solid-state-airplane.pdf) (PDF) that has NO moving parts.

gha_language: HTML

gha_license_id: NOASSERTION


text:
###Makefiles

It can be cumbersome to type all of the **gcc** lines over and over again, especially if you are making a lot of changes to the code and it has several libraries. The **make** facility solves this problem. You can use the following makefile to replace the compilation sequence above:

```
main: main.o util.o
        gcc -o main main.o util.o
main.o: main.c util.h
        gcc -c -g main.c
util.o: util.c util.h
        gcc -c -g util.c
```

Enter this into a file named **makefile**, and type **make** to build the executable. Note that you must precede all **gcc** lines with a tab. (Eight spaces will not suffice -- it must be a tab. All other lines must be flush left.)

This makefile contains two types of lines. The lines appearing flush left are **dependency lines**. The lines preceded by a tab are executable lines, which can contain any valid UNIX command. A dependency line says that some file is dependent on some other set of files. For example, **main.o: main.c util.h** says that the file **main.o** is dependent on the files **main.c** and **util.h**. If either of these two files changes, the following executable line(s) should be executed to recreate **main.o**.

Note that the final executable produced by the whole makefile is main, on line 1 in the makefile. The final result of the makefile should always go on line 1, which in this makefile says that the file **main** is dependent on **main.o** and **util.o**. If either of these changes, execute the line **gcc -o main main.o util.o** to recreate **main**.

It is possible to put multiple lines to be executed below a dependency line -- they must all start with a tab. A large program may have several libraries and a main program. The makefile automatically recompiles everything that needs to be recompiled because of a change.

If you are not working on a UNIX machine, your compiler almost certainly has functionality equivalent to makefiles. Read the documentation for your compiler to learn how to use it.

Now you understand why you have been including stdio.h in earlier programs. It is simply a standard library that someone created long ago and made available to other programmers to make their lives easier.


text:
---
title: "Week 3, Unit 1: Understanding the Challenge"
permalink: /week-3/unit-1/
excerpt: "In this unit you will get an overview of the **challenge for week 3**"
header:
  overlay_color: "#333"
  cta_label: "openSAP video"
  cta_url: "https://open.sap.com/courses/hcp3a1/items/3B5YQmrL7hlvZsvZExFiN3"
layout: single
sidebar:
  nav: "week-3"
---

{% include toc %}

> **Note:** On this page you will only find the presentation slides of the unit, without any additional context or explanations. Therefore **we strongly recommend to watch the [corresponding video](https://open.sap.com/courses/hcp3a1/items/3B5YQmrL7hlvZsvZExFiN3)** _(openSAP log-in required)_ in which Thomas Bieser, the course instructor, explains the slides in detail. This will greatly enhance your understanding of this units content.

## Presentation Slides

Here you get the sequence of presentation slides for the _challenge for week 3_.

### Slide 1: Title

[Top](#top-1)

### Slide 2: Week Overview

[Top](#top-2)

### Slide 3: Unit Overview

[Top](#top-3)

### Slide 4: Business Problem for the week

[Top](#top-4)

### Slide 5: Solution: Informed IT decision on IT equipment to be made

[Top](#top-5)

### Slide 6: Extension for this week: Collaborative Extension

[Top](#top-6)

### Slide 7: Extension Pattern: Point-to-point connectivity via OData

[Top](#top-7)

### Slide 8: Path towards the Collaborative Extension

[Top](#top-8)

### Slide 9: Involved Roles

[Top](#top-9)

### Slide 10: What you've learned in this unit

[Top](#top-10)

[**< Previous** Week 2, last Unit 5](../week-2/) | [**Up ^** Week 3](../) | [**Next >** Unit 2](../unit-2/)


text:
# Prometheus Certmanager Certificate Rules Testing Document

## Assumptions
* At any one moment, only **one** state (unknown, false, true) for the ready condition will have a value of one in the metrics.
* If the state of the ready condition is **not** true, then the certificate is assumed to be dysfunctional.

## Command to run tests
```
promtool test rules tests/*.yaml
```

# Alert: certManagerCertFailingToRenew

## Expression
```
(sum by (name) (time() > certmanager_certificate_renewal_timestamp_seconds) ) AND (sum by (name) (time() < certmanager_certificate_expiration_timestamp_seconds))
```

## Description

This alert should fire if the current date has passed the renewal time but it has not yet passed the expiry time.

## Truth Table (MC/DC)
|  Cond_1 	|  Cond_2 	|  Result 	|   Test Case	|
|-----------|-----------|-----------|---------------|
|   T	    |   T	    |   T	    |   	TC1     |
|   T	    |   F	    |   F	    |   	TC2     |
|   F	    |   T	    |   F	    |   	TC3     |

## TC1
### Input
* Renewal Date = Jan 1st 1970
* Expiry Date = Oct 2nd 2096

### Expected Output
* Alert fires: certManagerCertFailingToRenew

## TC2
### Input
* Renewal Date = Jan 1st 1970
* Expiry Date = Jan 1st 1970

### Expected Output
* No alert fires

## TC3
### Input
* Renewal Date = Oct 2nd 2096
* Expiry Date = Oct 2nd 2096

### Expected Output
* No alert fires

# Alert: certManagerCertFailure

## Expression
```
sum by (name) (certmanager_certificate_ready_status{condition="True"}==0) AND (sum by (name) (time() < certmanager_certificate_renewal_timestamp_seconds))
```

## Description

This alert should fire if the ready status of the certificate is **not** true but the current date is before the renewal date of the cert-manager certificate.
## Truth Table (MC/DC)
|  Cond_1 	|  Cond_2 	|   Result 	|   Test Case	|
|-----------|-----------|-----------|---------------|
|   T	    |   T	    |     T	    |   	TC4     |
|   T	    |   F	    |     F	    |   	TC5     |
|   F	    |   T	    |     F	    |   	TC6     |

## TC4
### Input
* Ready Status Condition = Not True (0)
* Renewal Date = Oct 2nd 2096

### Expected Output
* Alert fires: certManagerCertFailure

## TC5
### Input
* Ready Status Condition = Not True (0)
* Renewal Date = Jan 1st 1970

### Expected Output
* No alert fires

## TC6
### Input
* Ready Status Condition = True (1)
* Renewal Date = Oct 2nd 2096

### Expected Output
* No alert fires

# Alert: certManagerCertExpired

## Expression
```
sum by (name) (time() > certmanager_certificate_expiration_timestamp_seconds)
```

## Description

This alert should fire if the current date has exceeded the expiry date of the certificate.

## Truth Table (MC/DC)
|  Cond_1 	|    Result 	|   Test Case	|
|-----------|---------------|---------------|
|     T	    |   	T       |      TC7      |
|     F	    |   	F       |      TC8      |

## TC7
### Input
* Expiry Date = Jan 1st 1970

### Expected Output
* Alert fires: certManagerCertExpired

## TC8
### Input
* Expiry Date = Oct 2nd 2096

### Expected Output
* No alert fires

# Alert: certManagerAbsent

## Expression
```
absent(up{job="cert-manager"})
```

## Description

This alert should fire if cert-manager has disappeared from Prometheus service discovery. New certificates will not be able to be minted, and existing ones cannot be renewed until cert-manager is back.

## Truth Table (MC/DC)
|  Cond_1 	|    Result 	|   Test Case	|
|-----------|---------------|---------------|
|     T	    |   	T       |      TC9      |
|     F	    |   	F       |      TC10     |

## TC9
### Input
* Empty; No job; Only prometheus heartbeat signal

### Expected Output
* Alert fires: certManagerAbsent

## TC10
### Input
* Job exists

### Expected Output
* No alert fires

# Alert: certManagerHittingRateLimits

## Expression
```
sum by (host) (rate(certmanager_http_acme_client_request_count{status="429"}[5m])) > 0
```

## Description

This alert fires if Cert manager is hitting LetsEncrypt rate limits. Depending on the rate limit, cert-manager may be unable to generate certificates for up to a week.

## Truth Table (MC/DC)
|  Cond_1 	|    Result 	|   Test Case	|
|-----------|---------------|---------------|
|     T	    |   	T       |     TC11      |
|     F	    |   	F       |     TC12      |

## TC11
### Input
* A metric with HTTP status 429 that has a rate of 0.133 from [5m, 10m]

### Expected Output
* Alert fires: certManagerHittingRateLimits

## TC12
### Input
* A metric with HTTP status 429 that has a rate of 0 from [5m, 10m]

### Expected Output
* No alert fires


text:
# Morph's Screeps

Useful details for VSCode autocompletion etc.

https://github.com/Garethp/ScreepsAutocomplete/issues/44

Autocomplete code found here - put in root folder of project: https://github.com/Garethp/ScreepsAutocomplete
Add _references.js to the Autocomplete directory as per https://gist.github.com/quonic/d7a7d385c85846027a7ca3dd03a0e985

The latter claims that adding jsconfig.json:
`{ "compilerOptions": { "target": "ES6" }, "exclude": [ "node_modules" ] }`

in the project will make it all work.

Others claim this is needed at the top of each file:
`/// <reference path="..\..\ScreepsAutocomplete\_references.js" />`

Truth remains to be seen...

Fallback: Typescript declaration from https://github.com/screepers/Screeps-Typescript-Declarations - Open in VSCode


text:
#Environment variables

A default set of non-private environment configurations is provided here.

**DO NOT PLACE PRIVATE CONFIGURATION SECRETS HERE!**

##Docker
You can place custom configuration secrets in `var/secrets`.  Then modify your `docker-compose.yml` file to register your new secret file locations and provide access to containers if necessary. See https://docs.docker.com/compose/compose-file/#secrets for more information.

repository: honeylex/honeylex-cmf

repo_name: honeylex/honeylex-cmf


text:
# How to Use

Simply fork this project and start your runtime development in `lib.rs`.

## Updating Your Dependencies

For the time being, Substrate does not have any releases on Cargo, which means there is some magic involved with ensuring that all the dependencies of your module and the downstream runtime are the same.

This repository has all Substrate dependencies use:

```
branch = 'v1.0'
```

This means that the runtime is using this module must also be tied to the `v1.0` branch, not simply the same commit (`rev`).

If you are working with the Substrate node template or the [`substrate-package`](https://github.com/shawntabrizi/substrate-package/) which uses a specific git commit (`rev`), you can find/replace all instances of `branch = 'v1.0'` with:

```
rev = '<git-commit>'
```

This of course means that only runtimes with this setting on their side can use your module, at which point you may want to introduce different branches yourself for supporting different commits...

Our recommended pattern is to keep your module marked as `v1.0` and tell your runtime developer to update their dependencies. `v1.0` branch _should_ be stable.

> **Note:** Be sure to purge your projects of any `Cargo.lock` files when making changes like this!

## Adding New Dependencies

The Substrate blockchain framework can support any Rust libraries that can compile to Wasm. In general, this means that the libraries you use must compile with `no_std` enabled.

This also means you need to import your dependencies to only use their `std` feature when this module also uses it's `std` dependency.

The common pattern here look like:

1. Import your library with `default-features = false`

    ```
    [dependencies.parity-codec]
    default-features = false
    features = ['derive']
    version = '3.5'
    ```

2. Add your library to the `std` feature with its `std` feature enabled

    ```
    std = [
        'parity-codec/std',
        ...
    ]
    ```

We won't teach you the details of using Cargo, but feel free to [become a master](https://doc.rust-lang.org/cargo/).

## Building and Testing

Before you release your module, you should check that it can:

1. Build to Native:

    ```
    cargo build
    ```

2. Build to Wasm:

    ```rust
    cargo build --target=wasm32-unknown-unknown --no-default-features
    ```

3. Pass your tests:

    ```
    cargo test
    ```

## Update the README

Finally, update the [README](README.md) included with this template with the appropriate information for your module.

## Common Issues

Unfortunately keeping things modular can be a little tricky. Here are some common issues you may face.

### Developer Dependencies

When running `cargo build`, everything can compile fine, but when running `cargo test`, you may run into an import error like:

```rust
error[E0432]: unresolved import `runtime_io`
  --> src/lib.rs:67:6
   |
67 |     use runtime_io::with_externalities;
   |         ^^^^^^^^^^ use of undeclared type or module `runtime_io`
```

You may need to specify some developer dependency which is needed for your tests:

```
[dev-dependencies.runtime-io]
git = 'https://github.com/paritytech/substrate.git'
package = 'sr-io'
branch = 'v1.0'
```

> **Note:** `dev-dependencies` will always use `std`, so you should not set `default-features = false`.

### Forgetting `cfg_attr` for `no_std`

If you forget to include this line in your module's `lib.rs` file:

```rust
#![cfg_attr(not(feature = "std"), no_std)]
```

You will get errors like this when trying to compile your runtime:

```rust
error: duplicate lang item in crate `sr_io`: `panic_impl`.
|
= note: first defined in crate `std`.

error: duplicate lang item in crate `sr_io`: `oom`.
|
= note: first defined in crate `std`.
```

### Using Mismatching Substrate Dependencies

We mentioned above how it is important that your runtime and your module have exactly the same dependency on the Substrate project. If they do not, you will get a lot of `trait bound` errors like this:

```rust
error[E0277]: the trait bound `Runtime: srml_system::Trait` is not satisfied in `Event`
   --> /Users/shawntabrizi/Desktop/temp/modular-node/runtime/src/lib.rs:112:6
    |
112 | impl system::Trait for Runtime {
    |      ^^^^^^^^^^^^^ within `Event`, the trait `srml_system::Trait` is not implemented for `Runtime`
    |
    = note: required because it appears within the type `Event`

error[E0277]: the trait bound `test_module::Module<Runtime>: template::sr_api_hidden_includes_decl_storage::hidden_include::Callable` is not satisfied in `Call`
   --> /Users/shawntabrizi/Desktop/temp/modular-node/runtime/src/lib.rs:184:6
    |
184 | impl sudo::Trait for Runtime {
    |      ^^^^^^^^^^^ within `Call`, the trait `template::sr_api_hidden_includes_decl_storage::hidden_include::Callable` is not implemented for `test_module::Module<Runtime>`
    |
    = note: required because it appears within the type `Call`

error[E0277]: the trait bound `Runtime: srml_system::Trait` is not satisfied
   --> /Users/shawntabrizi/Desktop/temp/modular-node/runtime/src/lib.rs:196:6
    |
196 | impl test_module::Trait for Runtime {
    |      ^^^^^^^^^^^^^^^^^^ the trait `srml_system::Trait` is not implemented for `Runtime`
```

repository: riusricardo/substrate-iot

repo_name: riusricardo/substrate-iot


text:
# O.4.0
    - `Date` is now const-constructible
    - `dbase_record!` keeps visibility token
    - Added `File` struct to read/write file in-place.
    - Fixed stack overflow error on files with many sub-sequent deleted record.
    - Added `TrimOption`, to choose how whitespaces in Charater fields should be
    trimmed.

# 0.3.0
    - Replaced `chrono` with `time` v0.3
    - Added support for reading/writing non-unicode database files via custom encodings.
      The optional `yore` feature/crate can be used for supporting basic codepages.
      The `code_page_mark` contained in the header is used to create the correct decoder.
    - Fixed writing visual fox pro files
    - Added `FieldType` to publicly exported types

# 0.2.3
    - Added `impl std::error::Error for dbase::Error`
    - Fixed deserialization implementation that would fail to deserialize if one `None`
      value was encountered (issue #30, PR #31)

# 0.2.2
    - Fixed files written, their record size was wrong by one byte
    - Added the missing accessors for the `DateTime` and `Time` structs members

# 0.2.1
    - Implement `From<Record>` for `HashMap`
    - Implement `AsRef<HashMap>` & `AsMut<HashMap>` for `Record`
    - Add `derive(Clone)` for Record
    - Fix decimal places in writing numeric values
    - Performance improvement when reading (PR #21 and #23)

# 0.2.0
    - Added a `seek` method to the `Reader`
    - Added a `TableInfo` struct and a `into_table_info` method on the `Reader`.
      This `TableInfo` contains informations that can be used to create a new `TableWriterBuilder`
      that writes a dbf file with same 'layout' as the file from which the `TableInfo` comes from.
    - Added `TableWriterBuilder::from_table_info`
    - Changed `TableWriter::write` is now named `TableWriter::write_records` and takes any type that
      implements `IntoIterator<Item=&RecordType>` (so &[RecordType] is still a valid input).
    - Changed `TableWriter<T>` now requires `T` to implement `std::io::Seek and std::io::Read`,
      both `std::fs::File` & `std::io::Cursor` are example of valid `T`.
    - Added `TableWriter::write_record` to be able to write one record at a time.
    - Increased byteorder dependency from 1.3.0 to 1.4.3

# 0.1.2
    - Fixed some files not being properly read, by ensuring the reader seeks to the begining
      of the records after reading the header. (issue #11, Pull Request #12)

# 0.1.1
    - Added RecordIterator to the lib.rs exports
    - Added derive `Clone` to the `Reader`
    - Removed `pub` attribute from `FieldInfo`'s `name` struct member.

# 0.1.0
    - Added preliminary support for reading some 'VisualFoxPro' files
    - Added support for reading dBase / FoxPro files which have 'Memo' fields. (Writing Memo fields is not supported yet)
    - Added support for reading and writing the 'Datetime' field
    - Added support for reading and writing the 'Currency' field
    - Added Trait to allow users implementing it to read dBase records into their structs.
    - Added Trait to allow users implementing it to writre structs as dBase record.
    - Added optional feature "serde", to automatically impl the 2 trait described above
    - Added dependency to chrono

    - Changed how iteration on the records is made (/!\ very small breaking change)
    - Changed how dbase Writer are created, users now have to use the TableWriterBuilder
      to specify fields that constitute a record before being able to write records.
    - Changed the Error type.

    - Bumped byteorder dependency to 1.3.0

# 0.0.4
    - Added reading and writing of Float value #2
    - All dBase III types (Character, Numeric, Logical, Date, Float)
        are wrapped in Option<T> to handle empty / uninitialized values

# 0.0.3
    - Added writing of Character, Numeric, Logical, Date, Double, Integer

# 0.0.2
    - Added reading of Character, Numeric, Logical, Date, Double, Integer, types

repository: tmontaigu/dbase-rs

repo_name: tmontaigu/dbase-rs


text:
## Projects

### **blockchain-gateway**

JS library and CLI tools for sending Ethereum and Bitcoin transactions. Useful for multi-blockchain wallets and cross-chain exchanges.
[scifier.dev/blockchain-gateway](https://scifier.dev/blockchain-gateway)
[github.com/scifier/blockchain-gateway](https://github.com/scifier/blockchain-gateway)

### **mlp-generator**

Node.js project for generating, training, and analyzing simple artificial neural networks. This project was archived in the Arctic Vault program.
[scifier.dev/mlp-generator](https://scifier.dev/mlp-generator)
[github.com/scifier/mlp-generator](https://github.com/scifier/mlp-generator)

### **cv-materializer**

A React.js/typescript resume builder that is using markdown files for generating pages and concat them into a downloadable PDF. The project comes with an easy-to-configure GitHub Action that creates a static web page on GitHub Pages. To personalize the portfolio, the user should simply fork the project and follow the short instructions.
[scifier.dev/cv-materializer](https://scifier.dev/cv-materializer)
[github.com/scifier/cv-materializer](https://github.com/scifier/cv-materializer)

### **geth-contracts-disallowed**

Go-ethereum 1.8.14 client with modified PoA protocol - the contract deployment is allowed for whitelist external accounts and contract accounts only.
[github.com/uloxio/geth-contracts-disallowed](https://github.com/uloxio/geth-contracts-disallowed)

### **ws-frame-decoder**

JS library for decoding raw WebSocket frames according to RFC6455 Framing Protocol.
[github.com/uloxio/ws-frame-decoder](https://github.com/uloxio/ws-frame-decoder)

repository: scifier/cv-materializer

gha_language: TypeScript

repo_name: scifier/cv-materializer


text:
# tv_rename

A tool to rename your favorites TV shows collection !

Written with Delphi for Windows XP, fixed for recent Windows.

But still using a very unreliable but working method to scrap series information :smile:

Date: around 2010

## Example

repository: bravesoftdz/tv-rename

repo_name: bravesoftdz/tv-rename


text:
Change log
==========

Current version: 5.1.0-dev

* Putting together various major modules that have been developed as the core
  Linguistica 5 Python library plus graphical user interface (GUI) and command line interface (CLI):
  - `lexicon`
  - `ngram`
  - `signature`
  - `fsm`
  - `manifold`
  - `trie`
  - `phon`
  - `gui`

* Test deployment