text:
# Direct Line Bot Sample

A sample bot and a custom client communicating to each other using the Direct Line API.

[![Deploy to Azure][Deploy Button]][Deploy DirectLine/Node]
[Deploy Button]: https://azuredeploy.net/deploybutton.png
[Deploy DirectLine/Node]: https://azuredeploy.net

### Prerequisites

The minimum prerequisites to run this sample are:
* Latest Node.js with NPM. Download it from [here](https://nodejs.org/en/download/).
* The Bot Framework Emulator. To install the Bot Framework Emulator, download it from [here](https://aka.ms/bf-bc-emulator). Please refer to [this documentation article](https://docs.botframework.com/en-us/csharp/builder/sdkreference/gettingstarted.html#emulator) to know more about the Bot Framework Emulator.
* Register your bot with the Microsoft Bot Framework. Please refer to [this](https://docs.botframework.com/en-us/csharp/builder/sdkreference/gettingstarted.html#registering) for the instructions. Once you complete the registration, update your bot configuration with the registered config values (See [Debugging locally using ngrok](https://docs.botframework.com/en-us/node/builder/guides/core-concepts/#debugging-locally-using-ngrok) or [Deploying to Azure](https://docs.botframework.com/en-us/node/builder/guides/deploying-to-azure/#navtitle]))
* **[Recommended]** Visual Studio Code for IntelliSense and debugging, download it from [here](https://code.visualstudio.com/) for free.

#### Direct Line API
Credentials for the Direct Line API must be obtained from the Bot Framework developer portal, and will only allow the caller to connect to the bot for which they were generated.
In the Bot Framework developer portal, enable Direct Line in the channels list and then, configure the Direct Line secret and update its value in [DirectLineClient's app.js](DirectLineClient/app.js#L8) (`directLineSecret` variable).
Refer to [this](https://docs.botframework.com/en-us/csharp/builder/sdkreference/gettingstarted.html#channels) for more information on how to configure channels.

![Configure Direct Line](images/outcome-configure.png)

#### Publish
Also, in order to be able to run and test this sample you must [publish your bot, for example to Azure](https://docs.botframework.com/en-us/node/builder/guides/deploying-to-azure/). Alternatively, you can [Debug locally using ngrok](https://docs.botframework.com/en-us/node/builder/guides/core-concepts/#debugging-locally-using-ngrok).
Remember to update the environment variables with the `MICROSOFT_APP_ID` and `MICROSOFT_APP_PASSWORD`. If you are running the sample using Visual Studio Code, remember to update [launch.json](DirectLineBot/.vscode/launch.json#L19-L20) with the environment variables.

### Code Highlights

The Direct Line API is a simple REST API for connecting directly to a single bot. This API is intended for developers writing their own client applications, web chat controls, or mobile apps that will talk to their bot. In this sample, we are using the [Direct Line Swagger file](https://docs.botframework.com/en-us/restapi/directline/swagger.json) and [Swagger JS](https://github.com/swagger-api/swagger-js) to create a client for Node that will simplify access to the underlying REST API. Check out the client's [app.js](DirectLineClient/app.js#L8-L19) to see the client initialization.

````JavaScript
var directLineSecret = 'DIRECTLINE_SECRET';

var directLineClient = new Swagger(
    {
        spec: directLineSpec,
        usePromise: true,
    }).then((client) => {
        // add authorization header
        client.clientAuthorizations.add('AuthorizationBotConnector', new Swagger.ApiKeyAuthorization('Authorization', 'BotConnector ' + directLineSecret, 'header'));
        return client;
    }).catch((err) =>
        console.error('Error initializing DirectLine client', err));
````

Each conversation on the Direct Line channel must be explicitly started using the `client.Conversations.Conversations_NewConversation()` function.
Check out the client's [app.js createConversation](DirectLineClient/app.js#L21-L29) function which creates a new conversation.

````JavaScript
// once the client is ready, create a new conversation
directLineClient.then((client) => {
    client.Conversations.Conversations_NewConversation()                            // create conversation
        .then((response) => response.obj.conversationId)                            // obtain id
        .then((conversationId) => {
            sendMessagesFromConsole(client, conversationId);                        // start watching console input for sending new messages to bot
            pollMessages(client, conversationId);                                   // start polling messages from bot
        });
});
````

Once the conversation is created, a `conversationId` is returned that we can use to call other endpoints to poll or send messages.
User messages are sent to the Bot using the Direct Line Client `client.Conversations.Conversations_PostMessage` function using the `conversationId` generated in the previous step.

````JavaScript
// Read from console (stdin) and send input to conversation using DirectLine client
function sendMessagesFromConsole(client, conversationId) {
    var stdin = process.openStdin();
    process.stdout.write('Command> ');
    stdin.addListener('data', function (e) {
        var input = e.toString().trim();
        if (input) {
            // exit
            if (input.toLowerCase() === 'exit') {
                return process.exit();
            }

            // send message
            client.Conversations.Conversations_PostMessage(
            {
                conversationId: conversationId,
                message: {
                    from: directLineClientName,
                    text: input
                }
            }).catch((err) => console.error('Error sending message:', err));

            process.stdout.write('Command> ');
        }
    });
}
````

Messages from the Bot are continually polled from the API using an interval. Check out the client's [app.js](DirectLineClient/app.js#L61-L69) usage of `client.Conversations.Conversations_GetMessages` function which retrieves conversation messages newer than the stored watermark. Messages are then filtered from anyone but our own client using the [`printMessages`](DirectLineClient/app.js#L73-L88) function.

````JavaScript
var watermark = null;
setInterval(() => {
    client.Conversations.Conversations_GetMessages({ conversationId: conversationId, watermark: watermark })
        .then((response) => {
            watermark = response.obj.watermark;                                 // use watermark so subsequent requests skip old messages
            return response.obj.messages;
        })
        .then((messages) => printMessages(messages))
}, pollInterval);
````

The ChannelData property provides a way for you to send native metadata to take advantage of special features or concepts for a channel (see [Custom Channel Capabilities](https://docs.botframework.com/en-us/csharp/builder/sdkreference/channels.html) for more information).
Check out the [`printMessage`](DirectLineClient/app.js#L90-L104) function where the ChannelData custom content is deserialized and render appropriately.

````JavaScript
function printMessage(message) {
    console.log(message.text);
    if (message.channelData) {
        switch (message.channelData.contentType) {
            case "application/vnd.microsoft.card.hero":
                renderHeroCard(message.channelData);
                break;

            case "image/png":
                console.log('Opening the requested image ' + message.channelData.contentUrl);
                open(message.channelData.contentUrl);
                break;
        }
    }
}
````

### Outcome

To run the sample, you'll need to run both Bot and Client apps.

* Running Bot app
  1. Open a CMD console and CD to sample's `DirectLineBot` directory
  2. Run `node app.js`
* Running Client app
  1. Open a CMD console and CD to sample's `DirectLineClient` directory
  2. Run `node app.js`

To test the ChannelData custom messages type in the Client's console `show me a hero card` or `send me a botframework image` and you should see the following outcome.

![Sample Outcome](images/outcome.png)

### More Information

To get more information about how to get started in Bot Builder for Node and Direct Line API please review the following resources:
* [Bot Builder for Node.js Reference](https://docs.botframework.com/en-us/node/builder/overview/#navtitle)
* [Bot Framework FAQ](https://docs.botframework.com/en-us/faq/#i-have-a-communication-channel-id-like-to-be-configurable-with-bot-framework-can-i-work-with-microsoft-to-do-that)
* [Direct Line API](https://docs.botframework.com/en-us/restapi/directline/)
* [Direct Line Swagger file](https://docs.botframework.com/en-us/restapi/directline/swagger.json)
* [Swagger-JS](https://github.com/swagger-api/swagger-js)
* [Custom Channel Capabilities](https://docs.botframework.com/en-us/csharp/builder/sdkreference/channels.html)
* [Debugging locally using ngrok](https://docs.botframework.com/en-us/node/builder/guides/core-concepts/#debugging-locally-using-ngrok)

repository: Dekapri/bot-builder-samples

repo_name: Dekapri/bot-builder-samples


text:
# Components

> TODO Add these components in a separate package called @vue-accounts/bare-components

## Creating your own Components
Creating your own form is very easy. Simply add the right mixin and build the template like the below example:

```vue
<template>
  <form @submit.prevent="submit">
    <p><strong>Status:</strong> {{status}}</p>

    <input type="text" name="email" v-model="email" placeholder="Email" />
    <input type="password" name="password" v-model="password" placeholder="Password" />

    <p v-if="error"><strong>Error:</strong> {{error}}</p>

    <input type="submit" value="Login" />
  </form>
</template>

<script>
  import { LoginFormMixin } from '@vue-accounts/core';

  export default {
    mixins: [LoginFormMixin],
  };
</script>
```

The `@submit` event will trigger the mixin to call the right method.

## Component Mixins
Component mixins simplify the creation of custom components by providing standard functionality to componens.
An example of this functionality. Below is a list of available mixins

### BaseForm
Forms the base functionality for all the accounts forms. It calls the associated methods
and tracks the status of this progress (idle, submitting, success, error). It gives the following states:

#### Usage
```vue
export default {
  mixins: [BaseFormMixin],
  method: '<method>',
}
```

| Prop | Type | Description | Possible values | Default value |
|------|-------------|-----------------|---------------|------|
|status| String | A string representing the submit / loading status | 'idle', 'submitting', 'success', 'error' | 'idle' |
|error | String | A string containing any error given when the method call fails |  |  '' |
|payload| Object| An object containing the payload that is going to be send or was send by the form | | {} |

### LoginForm
Extends the BaseForm mixin by passing the `$login` method property.

### RegistrationForm
Extends the BaseForm mixin by passing the `$register` method property.

### ForgotPasswordForm
Extends the BaseForm mixin by passing the `$forgotPassword` method property.

### ResetPasswordForm
Extends the BaseForm mixin by passing the `$resetPassword` method property
and by passing the token from the url's `token` query parameter into the payload of the form.

Auth component are in most cases accompanied by mixins that add the desired behavior. For
example the reset-password form mixin goes with a ResetPasswordMixin which extracts the reset token
from the url and adds it to the payload on submit.

## Forms

### Registration
Allows users to register themselves

### Forgot Password
Shows a form with at least an email input. This triggers a method that sends an e-mail with
a reset link to the user.

### Reset Password
Shows a form with 2 password fields that allows a user to reset its password.
One for field is for the actual new password and the other to verify it. On submit
a token from the url (added via the email) is added to the payload of the form

## Buttons
Some actions do not require a form and simply need to be clicked.

### Logout
Allows the user to log out

### Resend Verification E-mail
A button that when clicked, will trigger a store action which should resend a verification e-mail

## Alerts
Alerts give the user feedback about pending, successful or unsuccessful actions.

### E-mail Not Yet Verified

Shown when the user is allowed to and log-in with an un-verified e-mail.

### E-mail Verification Feedback

Shown when the user returns on your app from a verification e-mail. It can have 4 states:

- verifying
- success
- error

After success the alert will be removed after 3 seconds.

license: MIT

repository: chris-visser/vue-accounts

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: chris-visser/vue-accounts


text:
---
layout: post
title: "Install Chrome OS in a PC"
author: nikhil
categories: [tutorial]
image: assets/images/chromeos/install-chrome-os.jpg
tags: [chrome os]
---

There has been many people searching for the installation of Chrome OS on a old PC or a laptop. So, today we're gonna guide you how to install full chrome OS with access to Android from within Chrome OS on an old laptop or an old PC and this isn't using Chromium OS, Cloud OS or Fade OS this is Chrome OS that you can install on pretty much any Intel based PC.

This is full chrome OS for your laptop or your desktop we also have access to Android and the Google Play Store and you can install Linux apps just like you can with most of the newer Chromebooks out there this is actually really easy to install and use.

I'll give you a quick rundown first thing you're gonna need is a USB Drive 16 gigabytes or larger what we're gonna do is install Linux Mint on this USB Drive so you can run it live we're also gonna transfer our Chrome OS installation files to that USB.

Basically what we're gonna do is start up Linux Mint running live from the USB and then install Chrome OS we'll wipe the internal drive of the PC we're going to be installing this on so if you have Windows installed on your PC and you use it every day don't go doing this but if you have an extra laptop or an old desktop laying around you could definitely try installing and use Chrome OS.

I'm going to be using a separate Windows 10 PC to get my USB drive set up but you could always do this on Linux or Mac some of the applications we're going to use will be different on those operating systems but if you're ready to get Chrome OS installed on your laptop or PC let's go ahead and get started all right so let's go ahead and download everything we need we're gonna get this image set up on a USB Drive.

For all this process, we're going to download five files. They're:

- **Linux Mint**
- **Rufus**
- **Brunch Files**
- **Install.sh File**
- **Chrome OS File**

The first thing you'll need is that USB Drive we do recommend at least the 16 gigabyte Drive

#### Downloading Required Files:

**1.** We need to do is download Linux Mint from [here](https://www.linuxmint.com/download.php). and we're just gonna use this as a live USB so we can install Chrome OS using this operating system we're gonna run this all from the USB. Download the appropriate version ie., either 32 bit or 64 bit.

**2.** Then download [Rufus](https://rufus.ie/) that allows us to flash that image to a USB Drive.

**3.** Now, download the latest version of [Brunch](https://github.com/sebanc/brunch/releases) from GitHub. As of now the latest version is 4.19.

**4.** Now we actually need to get the Chrome OS image and from this [link](https://cros-updates-serving.appspot.com/) you're gonna find **Rammus** in the page using Find in page(**Ctrl+F**) and **download the latest recovery build and extract it**. As of this post, it is 80, but it could be higher. This this the largest file you're going to download and it's going to be around 1.2 GB.

**5.** The final thing we'll need is the install.sh file. For this you need to go to this [page](https://raw.githubusercontent.com/shrikant2002/ChromeOS/master/install.sh) and right click and save it as install.sh.

#### Getting ready with the bootable drive:

Now place all of the downloaded files on to a single directory or on to your desktop.

All the files you'll be having are Linux Mint, Rufus, Brunch, Chrome OS Image and install.sh.

First thing we need to do is flash our drive with Linux man we're gonna start up Rufus from within this application we need to make sure that we have our USB drive chosen just make sure it is the correct USB.

We're gonna navigate to where we have the Linux Mint image and finally we'll click start this is gonna flash Linux Mint to that USB drive so we can boot it up live on our PC you get a couple warnings Yes and we want to write this in an ISO image mode click OK all the data on the USB Drive will be destroyed. We're now done with flashing the Linux Mint to our USB Drive.

Now it's time to get the other files we downloaded. Create a folder called Chrome OS and move the install.sh file that we've downloaded inside of this folder. Now extract both the files Brunch and Chrome OS image and move all the files from both of them into the Chrome OS folder you've created. Then move the Chrome OS folder into the USB Drive.

Now, finally your bootable drive is ready.

#### Installation:

1. Firstly, go to your machine BIOS menu(ie., by clicking either **Esc**, **F2**, **F9**, **F10**, or **F12** while turning on the machine) and **Disable Secure Boot** and **Boot Option** to **UEFI**.

2. Then plug in your bootable USB and enter in to the boot menu and click on the USB Drive.
3. After that select the Linux Mint option to run it live from the USB Drive.

4. Once you have selected Linux Mint, you'll be directed to the Desktop of Linux Mint.
5. Make sure you're online while you're using Linux Mint.
6. Then go to the Chrome OS folder we've created in the File Explorer.

7. Then right click and open terminal in Chrome OS directory.

8. Now, in terminal run the command `sudo sh install.sh`. In this step it will download some dependences, that's why you need to be online.

9. Now we're going to install the Chrome OS and make this a strictly Chromebook. To do so, type **Yes**.

10. It will take around 5-10 minutes depending on your internet connection.

11. Once the process is done, you can either type `sudo reboot` or go to the menu and select **Restart** and remove the USB Drive.

Then your pc will be booted with Chrome OS and follow the instructions on the screen to setup the device.

For more detailed procedure of installation, go through the video by [Kedar Nimbalkar](https://www.youtube.com/channel/UCjQ-YHwNTbUQLVzZQFjsDsQ)

By the by subscribe to Kedar Nimbalkar for cool videos on operting systems like triple booting a system.
Content and Image credits: [Kedar Nimbalkar](https://www.youtube.com/channel/UCjQ-YHwNTbUQLVzZQFjsDsQ)


text:
# cuda-plans

This repo is for anything to make [CUDA](https://developer.nvidia.com/cuda-zone) work within [Chef Habitat](https://habitat.sh)

## License

All things in here are MIT Licensed except for the following plans:

- gcc8
  - Apache 2.0
  - Forked from [core/gcc](https://github.com/habitat-sh/core-plans/tree/master/gcc)
- gcc8-libs
  - Apache 2.0
  - Forked from [core/gcc-libs](https://github.com/habitat-sh/core-plans/tree/master/gcc-libs)

repository: bdangit/cuda-plans

gha_license_id: MIT

repo_name: bdangit/cuda-plans


text:
# Brick Battery

## Quick description

A piece of Python software to run heating harder at home when the sun
shines, charging up bricks with heat.

It runs Python for the controller and comes with a mobile friendly Web UI in Javascript for the monitoring and configuration.

It helps achieve greater PV self-consumption and import less when grid power is more expensive in the evening, as shown below on the daily values graph:

## Some software specs

- Python3.5 or later
- Implements a client for the SolarEdge API (to get power of inverter and grid
net meter)
- Implements a ModBus TCP SunSpec client as an alternative more reliable way to
poll the inverter from the LAN
- Implements a client for the Daikin API to monitor and control A/C units
- Runs a poll loop every 3 seconds to check grid import/export
and aircon consumptions
- Adjusts every preset interval if needed the aircon control settings to
get the grid import/export value fall within the pre-defined target.
This gives enough time for the aircon compressors
to adjust their running regime.
- Logs sensors and controls to know what is going on during the system operation
- Has a sleep mode setting for the aircons to operate in when PV generation has
stopped for the day
- Polls all APIs asynchronously (concurrently)
- Provides its own API used by the web UI to monitor usage and configure settings

## The physical setup:
- Canberra climate: cold winters but sunny and relatively warm days with cool
nights
- About 5kW of PV generation in a split array using a SolarEdge HD Wave inverter
connected to a WattMeter for the grid net consumption monitoring. This roughly
provides a 3kW peak of alternative current generation in the middle of a sunny
winter day.
- 2x Daikin Ururu Sarara 3.5kW (FTXZ-N 35) split air conditioners each connected
to a Daikin wifi module. These fancy aircons run a humidifier but Daikin
"forgot" to advertise the fan speed settings through the LAN API controller
- A Raspberry Pi 3 running Debian
- 3-phase grid supply, 1-phase inverter

## Background

This program helps with a problem I faced setting up home automation.
I installed rooftop solar generation and wanted to maximise my self-consumption
to avoid selling cheaply electricity during the day only to have to buy it back
at a higher price later during the night, hence the battery side of things.
But electric batteries are still a bit expensive (at least in 2019).

This is particularly prevalent in winter when PV generation is limited but
heating needs are high.
Luckily I have the following playing on my side:
- Can monitor in real-time instantaneous power of PV generation and grid
import/export
- Can command settings and quite accurately estimate power consumption of the
2 inverter-based air-conditioning systems used to heat up the house
- The house itself has a high thermal mass as all the inner walls are made of
solid brick

Here we have all the ingredients to create an energy storage system using the
most degraded form of energy: heat! (and the name to the new project)

In the utility industry this system is commonly referred to as an active
Distributed Energy Resources or active DER. From the grid point-of-view, the
system helps by storing energy instead of releasing it to the grid when all the
neighbours are at work and their houses are not consuming much (this is not so
much of a problem yet with current penetration rate of PV generation) and most
importantly avoiding the extra consumption in evening during the peak hour
demand.
Obviously, my main consideration here is more, as stated earlier, to minimise
my energy bill by increasing my self-consumption (and have a bit of fun
designing the system).

The system was initially polling the SolarEdge cloud API but after I found it
not always reliable and sometimes too laggy (>2/3min between refreshes), I
found that I could fairly simply use the ModBus over TCP capability from the
inverter and get all data from the LAN. This uses the SunSpec standard so it
should be easy to use with any non-SolarEdge inverter.

## User interface

See the UI Readme page for the A/C remote and BBC
remote using simple Javascript web applications.

repository: quent/brick-battery

repo_name: quent/brick-battery


text:
We release biweekly (every two weeks), promoting a recent
nightly build. The majority of releases are supported for 6 weeks.

## Long Term Support

Every 24 weeks (roughly twice a year), a release has "long term support" for
roughly 48 weeks - until two more LTS releases have been made. If the release
due at that time is delayed, support is extended.

Here's a table of recent LTS releases as well as *expected* future LTS releases:

| Version |    \*Release Date       |    \*End of Support       |      MacOS Homebrew Support       |
| ------- | ----------------------- | ------------------------- | --------------------------------- |
| [4.153¹](https://hhvm.com/blog/2022/03/17/hhvm-4.153.html) | March 17, 2022        | *February 16, 2023*      | Supported     |
| [4.128¹](https://hhvm.com/blog/2021/09/21/hhvm-4.128.html) | September 21, 2021    | *August 24, 2022*        | Supported     |
| [4.102²](https://hhvm.com/blog/2021/03/23/hhvm-4.102.html) | March 23, 2021        | March 17, 2022           | Not Supported |
| [4.80](https://hhvm.com/blog/2020/10/21/hhvm-4.80.html)    | October 21, 2020      | September 21, 2021       | Not Supported |
| [4.56](https://hhvm.com/blog/2020/05/04/hhvm-4.56.html)    | May 4, 2020           | April 5, 2021            | Not Supported |
| [4.32](https://hhvm.com/blog/2019/11/19/hhvm-4.32.html)    | November 19, 2019     | October 21, 2020         | Not Supported |

\* *Dates in italics signify an **expected** date.*

¹ We are continuing support for MacOS Homebrew on LTS releases (4.128 and 4.153) until they reach EOL, but [we are stopping nightly builds of HHVM on MacOS homebrew](https://hhvm.com/blog/2022/06/17/deprecating-homebrew.html), will no longer be publishing MacOS homebrew packages for new releases, and will not be testing new versions of HHVM on MacOS going forward.

² HHVM 4.102 was promoted to lts status instead of HHVM 4.104. Its expected support duration has been extended by 2 weeks (to a total of 50) to compensate for the "early start". See the [blog post](https://hhvm.com/blog/2021/03/29/extending-hhvm-4.102-support.html) for more information.

repository: hhvm/user-documentation

branch_name: refs/heads/main

gha_language: Hack

gha_license_id: NOASSERTION

repo_name: hhvm/user-documentation


text:
## Explanation

<!--
In a couple sentences, explain why this PR is needed and what it addresses. This should be an explanation a non-developer user can understand and covers the "why" question. It should also clearly indicate whether this PR represents an addition, a change, or a fix of existing behavior. This explanation will be used to assist in the release note drafting process.

THIS IS MANDATORY.
-->

## Related issue

<!--
Please link the GitHub issue this pull request resolves in the format of `Closes #1234`. If you discussed this change
with a maintainer, please mention her/him using the `@` syntax (e.g. `@JimBugwadia`).

If this change neither resolves an existing issue nor has sign-off from one of the maintainers, there is a
chance substantial changes will be requested or that the changes will be rejected.

You can discuss changes with maintainers in the [Kyverno Slack Channel](https://kubernetes.slack.com/).
-->

## Milestone of this PR
<!--

Add the milestone label by commenting `/milestone 1.2.3`.

-->

## What type of PR is this

<!--

> Uncomment only one ` /kind <>` line, hit enter to put that in a new line, and remove leading white spaces from that line:
>
> /kind api-change
> /kind bug
> /kind cleanup
> /kind design
> /kind documentation
> /kind failing-test
> /kind feature
-->

## Proposed Changes

<!--
Describe the big picture of your changes here to communicate to the maintainers why we should accept this pull request.

***NOTE***: If this PR results in new or altered behavior which is user facing, you **MUST** read and follow the steps outlined in the [PR documentation guide](pr_documentation.md) and add Proof Manifests as defined below.
-->

### Proof Manifests

<!--
Read and follow the [PR documentation guide](https://github.com/kyverno/kyverno/blob/main/.github/pr_documentation.md) for more details first. This section is for pasting your YAML manifests (Kubernetes resources and Kyverno policies) and Kyverno CLI test manifests which allow maintainers to prove the intended functionality is achieved by your PR. Please use proper fenced code block formatting, for example:

# Kubernetes resource

```yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: roles-dictionary
  namespace: default
data:
  allowed-roles: "[\"cluster-admin\", \"cluster-operator\", \"tenant-admin\"]"
```

# Kyverno CLI test manifest (please see docs for latest manifest format at https://kyverno.io/docs/kyverno-cli/). See kyverno/policies for complete examples of all related test files.

```yaml
name: prepend-image-registry
policies:
  - prepend_image_registry.yaml
resources:
  - resource.yaml
variables: values.yaml
results:
  - policy: prepend-registry
    rule: prepend-registry-containers
    resource: mypod
    # if mutate rule
    patchedResource: patchedResource01.yaml
    kind: Pod
    result: pass
```
-->

## Checklist

<!--
Put an `x` in the boxes that apply. You can also fill these out after creating the PR. If you're unsure about any of
them, don't hesitate to ask. We're here to help! This is simply a reminder of what we are going to look for before merging your code.
-->

- [ ] I have read the [contributing guidelines](https://github.com/kyverno/kyverno/blob/main/CONTRIBUTING.md).
- [ ] I have read the [PR documentation guide](https://github.com/kyverno/kyverno/blob/main/.github/pr_documentation.md) and followed the process including adding proof manifests to this PR.
- [ ] This is a bug fix and I have added unit tests that prove my fix is effective.
- [ ] This is a feature and I have added CLI tests that are applicable.
- [ ] My PR needs to be cherry picked to a specific release branch which is <replace>.
- [ ] My PR contains new or altered behavior to Kyverno and
  - [ ] CLI support should be added and my PR doesn't contain that functionality.
  - [ ] I have added or changed [the documentation](https://github.com/kyverno/website) myself in an existing PR and the link is:
  <!-- Uncomment to link to the PR -->
  <!-- https://github.com/kyverno/website/pull/123 -->
  - [ ] I have raised an issue in [kyverno/website](https://github.com/kyverno/website) to track the documentation update and the link is:
  <!-- Uncomment to link to the issue -->
  <!-- https://github.com/kyverno/website/issues/1 -->

## Further Comments

<!--

repository: kyverno/kyverno

gha_language: Go

repo_name: kyverno/kyverno


text:
//[viewmodel](../../../index.md)/[com.motorro.rxlcemodel.viewmodel](../index.md)/[BaseViewModel](index.md)/[initialized](initialized.md)

# initialized

[androidJvm]\
var [initialized](initialized.md): Boolean = false

Is model initialized

repository: motorro/RxLceModel

gha_language: Kotlin

repo_name: motorro/RxLceModel


text:
# How to contribute

I'm really glad you're reading this, because we need active developers to help this project come to fruition.
We're establishing a community process for contributors to earn RHOC working for the coop. See video [24:06 HJ explains Members Decentralized Budgeting](https://www.youtube.com/watch?v=7Li4g4qDF6M&t=1486s) and video [RChain, Decentralized budgeting and spending](https://www.youtube.com/watch?v=m6xiTWbEdpA).

Everyone is welcome to participate. Contributing doesn’t just mean coding; there are many different ways for you to get involved, including community activism, marketing, business development, design, and governance.

### Communication

[RChain](https://rchain.coop) has multiple channels to make easy communication possible within the growing community. There is a full list of comm channels in the [FAQ](https://github.com/rchain/reference/blob/master/faq.md) but these are the collaborative channels:
- We work together and keep each other updated through [Github/RChain/Members](https://github.com/rchain/Members).
- We're experimenting with [Mattermost](https://rchain.divvydao.net/community/channels/town-square) and [Gitter](https://gitter.im/rchain/Rholang) to create insight in who does what when and why.
- Telegram [RChain Coop chat group](https://t.me/rchain_coop) is for chat, while Telegram [RChain Coop Official Announcements channel](https://t.me/rchain_official) carries official announcements. There is also a [RChain_Official_Chat_CN](https://t.me/RChain_Official_Chat_CN) group.
- We've moved from [Slack](https://ourchain.slack.com/messages?) to a private [Discord](https://discordapp.com/channels/349667445566472202/357561188676009986) server. Discord has several channels to discuss about all kind of things (to join see [Becoming a Member](#becoming-a-member) below). The goal is to create actionable issues in [Github/Members](https://github.com/rchain/Members/) that are handled by the community.
- The different environments are bridged together. So you would see messages from for example Discord in Mattermost, Telegram, or Gitter.
- There is a QQ group for #RChain: 530718666.
- We use [Google Groups](https://groups.google.com/forum/#!forum/rchain) for interaction through email and getting access to the RChain Google drive and documents.
- There are weekly conference calls with unedited archives on [Youtube](https://www.youtube.com/channel/UCSS3jCffMiz574_q64Ukj_w).
- There is a weekly [Member zoom meeting](https://zoom.us/s/197490909) on Wednesdays, 06:00 PM UTC (Amsterdam +1, New York -5, Seattle -8, Beijing +8), where we discuss the issues that need to be worked upon.
- And of course our [website](https://rchain.coop).

### Collaboration

Through [Github/Members](https://github.com/rchain/Members/) issues are created by anyone. It's up to us to handle all those issues in an organized manner, based on self organization and decentralization. We trust in skills and common sense to solve the issues and get rewarded in a reasonable way in RHOC.

- Work items are represented by [issues](https://github.com/rchain/Members/issues/).
- To make one or join work on one, you need to:

  1. [ ] get/have a [Github account](https://github.com/rchain/Members)
  2. [ ] request a Github collaborator role from @lapin7 in one of the comm channels, or mail [ops@rchain.coop](ops@rchain.coop), to get an invite
  3. [ ] then confirm the [collaboration invite](https://github.com/rchain/Members/invitations) for the repository [rchain/Members](https://github.com/rchain/Members)

- It's not mandatory but it really helps to become a RChain Member and get a Discord account. This requires a $20 membership fee and KYC. See [Becoming a Member](#becoming-a-member) below.
  1. [ ] <img src="https://user-images.githubusercontent.com/1913335/32598353-e489f158-c539-11e7-9656-4bcbb55718d2.png" alt="registration" width="200" />
  2. [ ] This is the #bounties channel in Discord:
  ![image](https://user-images.githubusercontent.com/1913335/32598502-3f0ddc98-c53a-11e7-85e9-f95fc799dede.png)

#### Decentralized Budget Allocation
- Budgets are allocated to work items by at least three Members. The average of three suggestions defines the budget.
- Ops (@lapin7, HJ) explains it in the video [RChain, Decentralized budgeting and spending](https://www.youtube.com/watch?v=m6xiTWbEdpA)
- Members suggest a budget to resolve the issue.
- Go to the spreadsheet [Pub Member Budget Allocation-Spending](https://docs.google.com/spreadsheets/d/1uxuxx8YN17KCIWcH1cUoGuSm2hAnIya2iAc6wxoaq1o/edit#gid=634479823) TAB "Budget 201711"
![image](https://user-images.githubusercontent.com/1913335/32597438-01a23d84-c537-11e7-916e-c9f12df80480.png)
- Find an issue that you want to allocate a budget to, like #115 "Community Co-Operators"
- Type your Github-name in the yellow column, for example AR66 gets lapin7
- Type your suggested budget, like $5000.00. The current budget becomes then $5000.00 (in K66). It's added to the budget of the previous month.
![image](https://user-images.githubusercontent.com/1913335/32597751-ed21061e-c537-11e7-9a0b-c9cccc48bc86.png)
- The Operation manager ([ops@rchain.coop](ops@rchain.coop)) can also add comments with email assignments to the cells of the issue in this Gsheet in order to stimulate setting budgets.

#### Decentralized Reward Allocation
- RHOC are distributed monthly based on invoices.
- During the month each collaborator decides how the budget in RHOC is distributed over the collaborators as a reward for the participation. The average of three reward suggestions sets the personal reward for each collaborator.
- Go to spreadsheet [Pub Member Budget Allocation-Spending](https://docs.google.com/spreadsheets/d/1uxuxx8YN17KCIWcH1cUoGuSm2hAnIya2iAc6wxoaq1o/edit#gid=634479823) TAB "Rewards 201711"
![image](https://user-images.githubusercontent.com/1913335/32599161-f91d53f6-c53b-11e7-9ee8-8b31733b98fb.png)
- In column Q and R you see respectively the percentage distribution and the github name of the member, who gave the score according to his/her insight about the work being done by him/her self and the other ones who have done work on the issue.
- In column M you can type your github name. Your name appears then in column Q for example.
- In column R you can set then the percentages for yourself and the other collaborators.
-<EMAIL_ADDRESS>can also add comments with email assignments to the cells of the issue in this Gsheet in order to stimulate setting rewards.

#### Centralized Payment process
- At the end of the month the situation will be frozen. No changes can be made anymore to either budgets or rewards. The payment process starts at the beginning of the month.
- The collaborator receives an email with a pre-filled invoice and also the needed data if the collaborator wants to make his/her own invoice. The collaborator stores a PDF version of the pre-filled invoice or their own invoice in his/her personal [Gdrive of Rchain](https://drive.google.com/drive/folders/0B5I9qM5f_1cfeUZoV01EYjdmOEE) Invoices.
- The collaborator then emails [invoices<EMAIL_ADDRESS>with a link to the PDF invoice.
- If a member does regular work per month, then a Statement of Work can be set up. This process will be available soon.
- If the process works well, then of course it will be decentralized further to work areas or regions.

#### Tax
- RChain Coop has to comply with the tax rules of the IRS. That means that at the end of the year RChain has to provide a list of payouts to contributors, with the amounts, through form 1099.
- If a contributor's rewards are more then $600 per year, then a [Fw9 tax form](https://www.irs.gov/pub/irs-pdf/fw9.pdf) has to be filled out and stored in the [personal folder](https://drive.google.com/drive/folders/0B5I9qM5f_1cfeUZoV01EYjdmOEE) Tax.
- For US aliens living outside of the USA, a form [Fw4 tax form](https://www.irs.gov/pub/irs-pdf/fw4.pdf) has to be filled out.
- As soon as the [Operation<EMAIL_ADDRESS>is notified of the declaration, Ops will transfer RHOC to the provided ETH-addresses.

#### Reporting
- Finally management reports will be generated and presented in Debriefings of RChain.

The first monthly cycle was Aug 2017. [Ops](ops@rchain.coop), (HJ or lapin7) presented this process Aug 30 in
[RChain Community Debrief 40 (24:06)](https://www.youtube.com/watch?v=7Li4g4qDF6M&t=1486s). An overview of the [budgets and rewards](https://docs.google.com/spreadsheets/d/1uxuxx8YN17KCIWcH1cUoGuSm2hAnIya2iAc6wxoaq1o/edit#gid=1751357908) is available.

## Becoming a Member

By joining the Cooperative you will participate in the lively conversation of the RChain community. Members can access the private Discord channel (no trolls or scammers) with direct access to the developers and governance decision making.

### Process

- [Sign up](https://member.rchain.coop/#/sign-up) for RChain membership, upload your id document, and pay the $20 membership fee.
- You will receive an invite link to the RChain Discord.
- Create a [Discord](https://discordapp.com/) account if you don't have one.
- On Discord, go to the #verification channel and request verification. A 'verifier' will contact you (depending on the time of day this might not be immediate).

#### 4 Membership requirements

The RChain representative will check the following:
1. [Membership agreement](https://github.com/rchain/legaldocs/blob/master/Coop%20Membership%20Agreement.pdf) affirmed
2. Check the photo of govt issued ID
3. Verify payment of membership fee
4. Verify face on live video

#### Promotion to MEMBER

When the four membership requirements are met and recorded, a Discord admin will promote the user to ROLE=MEMBER and append a ':' to the member's Discord alias for proof of individuality.

Welcome to the club!


text:
---
title: "Addon Authors, please prepare for Eden"
date: 2011-12-02T03:00:00Z
tags:
  - Developer
author: Team XBMC
---

This is just a quick note for addon authors.

[![XBMC API Changes](/images/blog/XBMCAPIChanges-216x300.webp "XBMC API Changes")](/images/blog/XBMCAPIChanges.webp)
 "Please return your trays and seatbacks to upright position and prepare for Eden."

XBMC 11.0 Eden represents the first update to the addon repository since Dharma was released and a number of API changes have occurred in between these two releases.  You are doing a great job. The Team would like to recommend that those authors who have not yet upgraded to Eden do so now.

For more specifics on skinning, scripting, json, Python calls, and similar addon API updates, please visit:

[https://kodi.wiki/view/Eden_API_Changes](https://kodi.wiki/view/Eden_API_Changes)

Thank you for flying Air XBMC. We are nearing the runway.

repository: ECCx/kodi-tv

repo_name: ECCx/kodi-tv


text:
---
layout: post
title:  "Day 5: Going over Rust's Ownership and Borrowing"
date:   2016-07-08
categories: [log]
comments: false
tags: [log, rust]
authors: Jeena and Malisa
---

## Things we did:
- Reviewed Rust's [Ownership] (https://doc.rust-lang.org/book/ownership.html) and [Borrowing] (https://doc.rust-lang.org/book/references-and-borrowing.html).
- After reviewing, went through each line of the normalize function from yesterday.

## Things we learned:
- In Rust, only one thing can own a mutable reference at a time.
- Many things can have a reference to another thing, but only if it's an immutable reference.
- Dereferencing is a tricky concept. It can also be done in a couple different ways. For example two code snippets below would do the same thing:
{% highlight rust %}
      for byte in &value[first_index..last_index + 1] {
                        normalized_value.push(*byte);   // dereferencing here
                        }
{% endhighlight %}

{% highlight rust %}
      for &byte in &value[first_index..last_index + 1] { // destructuring here
                        normalized_value.push(byte);
                        }
{% endhighlight %}

## TODO:
- Learn more Rust (always!)
- Implement more of the Headers methods
- Write tests for the append() method
    - Finish writing test for normalize function


text:
# lndmon

#### A drop-in monitoring solution for your lnd node using Prometheus and Grafana.

<img src="dashboard.png">

## What is this?

`lndmon` is a drop-in, dockerized monitoring/metric collection solution for your
individual lnd nodes connected to bitcoin. With this system, you'll be able to
closely monitor the health and status of your `lnd` node.

There are three primary components of the `lndmon` system:

1. [lnd](https://github.com/lightningnetwork/lnd) built with the `monitoring`
   tag, which enables lnd to export metrics about its gRPC performance and
   usage. These metrics provide insights such as how many bytes lnd is
   transmitting over gRPC, whether any calls are taking a long time to complete,
   and other related statistics.

2. `lndmon`: while lnd provides some information, `lndmon` by far does the heavy
   lifting with regards to metrics. With `lndmon`'s data, you can track routing
   fees over time, track how the channel graph evolves, and have a highly
   configurable "crystal ball" to forecast and de-escalate potential issues as
   the network changes over time. There is also a strong set of metrics for
   users who want to keep track of their own node and channels, or just explore
   and create their own lightning data visualizations.

3. Last but not least, `lndmon` uses [Grafana](https://grafana.com/) as its
   primary dashboard to display all its collected metrics. Grafana is highly
   configurable and can create beautiful and detailed graphs organized by
   category (i.e., chain-related graphs, fee-related graphs, etc). Users have
   the option of making their Grafana dashboards remotely accessible over TLS
   with passwords to ensure their data is kept private.

## Why would I want to use this?

Monitoring can provide crucial insights into the health of large-scale
distributed systems. Without monitoring systems like `lndmon`, the only view
into the health of your lnd node and the overall network is (1) fragmented logs,
and (2) individually-dispatched `getinfo` and similar commands. By exporting and
graphing interesting metrics, one can get a real-time transparent view of the
behavior of your lnd node and the network. It's also cool to see how this view
changes over time and how it's affected by events in the larger bitcoin
ecosystem (i.e., "wow, the day [Lightning
App](https://github.com/lightninglabs/lightning-app) was released coincides with
the addition of 3000 channels to the network!").

## How do I install this?

Head over to [`INSTALL.md`](https://github.com/lightninglabs/lndmon/blob/master/INSTALL.md). It
also includes instructions to set up, access, and password-protect the dashboard
that comes with Prometheus, called the Prometheus expression browser, for those
interested in using it.

repository: lightninglabs/lndmon

repo_name: lightninglabs/lndmon


text:
---
title: New Office 365 user can not be found in directory
date: 2014-03-13T11:22:32+00:00
author: Janik von Rotz
slug: new-office-365-can-not-be-found-in-directory
images:
  - /wp-content/uploads/2014/03/Office-365-flat-Logo-e1394705523286.jpg
categories:
  - Office 365
tags:
  - activedirectory
  - provisioning
---
As part of the user provisioning process in my company every user account gets an Office 365 license.

2 days ago in the after noon I've created an new user account, synced it with DirSync and applied an new Office 365 E1 license.

When I've tried access the SharePoint Online website via ADFS SSO, I received an error message like this:

```text
<EMAIL_ADDRESS>can not be found in directory

Correlation ID: 812b329c-0ad4-702d-d866-1a5dd6a5d715
Date and Time: 13/03/2014 08:58:17
URL: https://example.vbluzern.com/?wa=wsignin1.0
User<EMAIL_ADDRESS>Issue Type: Partner User Invalid
```

I tried everything to get rid of this error. Recreating the user account, disable, enable, assign another license, compare with working accounts, but nothing could solve this issue.

However as I've browsed in the Technet forums I came along this issue Partner User Invalid when creating a new user account.. They described almost the same issue as mine. In the last answer somebody proposed simply to wait 24 hours after assigning the license.

And guess what! It worked!

24 hours after I've assigned the Office 365 license I could login with the new user account.

Thank you Microsoft for these detailed error reports :)