cwielenb/CNCF-Dataset huggingface dataset:
Project: Podman (App Definition and Development / Application Definition & Image Build)
File: isolation.md

Controls what type of isolation is used for running processes as part of `RUN` instructions. Recognized types include oci (OCI-compatible runtime, the default), rootless (OCI-compatible runtime invoked using a modified configuration and its --rootless option enabled, with *--no-new-keyring --no-pivot added to its create* invocation, with network and UTS namespaces disabled, and IPC, PID, and user namespaces enabled; the default for unprivileged users), and chroot (an internal wrapper that leans more toward chroot(1) than container technology). Note: You can also override the default isolation type by setting the BUILDAH\ISOLATION environment variable. `export BUILDAHISOLATION=oci`
Project: YDB (App Definition and Development / Database)
File: RELEASE-PROCEDURE.md

c-ares release procedure - how to do a release ============================================== in the source code repo -- edit `RELEASE-NOTES` to be accurate edit `configure.ac`'s `CARESVERSIONINFO`, and `CMakeLists.txt`'s `CARESLIBVERSIONINFO` set to the same value to denote the current shared object versioning. edit `include/aresversion.h` and set `ARESVERSION_*` definitions to reflect the current version. make sure all relevant changes are committed on the master branch tag the git repo in this style: `git tag -a cares-1140` -a annotates the tag and we use underscores instead of dots in the version number. run "./maketgz 1.14.0" to build the release tarball. It is important that you run this on a machine with the correct set of autotools etc installed as this is what then will be shipped and used by most users on *nix like systems. push the git commits and the new tag gpg sign the tarball upload the resulting files to https://c-ares.org/download/ in the c-ares-www repo edit `index.t` (version number and date), edit `changelog.t` (add the new release in there) commit all local changes tag the repo with the same tag as used for the source repo push the git commits and the new tag inform send an email to the c-ares mailing list. Insert the RELEASE-NOTES into the mail. celebrate suitable beverage intake is encouraged for the festivities
Project: external-secrets (Provisioning / Security & Compliance)
File: jenkins-kubernetes-credentials.md

Jenkins is one of the most popular automation servers for continuous integration, automation, scheduling jobs and for generic pipelining. It has an extensive set of plugins that extend or provide additional functionality including the . This plugin takes kubernetes secrets and creates Jenkins credentials from them removing the need for manual entry of secrets, local storage and manual secret rotation. The Jenkins credentials plugin uses labels and annotations on a kubernetes secret to create a Jenkins credential. The different types of Jenkins credentials that can be created are SecretText, privateSSHKey, UsernamePassword. Here are some examples of SecretText with the Hashicorp Vault and AWS External Secrets providers: ``` yaml {% include 'vault-jenkins-credential-sonarqube-api-token-external-secret.yaml' %} ``` ``` yaml {% include 'aws-jenkins-credential-sonarqube-api-token-external-secret.yaml' %} ``` Here are some examples of UsernamePassword credentials with the Hashicorp Vault and AWS External Secrets providers: ``` yaml {% include 'vault-jenkins-credential-harbor-chart-robot-external-secret.yaml' %} ``` ``` yaml {% include 'aws-jenkins-credentials-harbor-chart-robot-external-secret.yaml' %} ``` Here are some examples of basicSSHUserPrivateKey credentials with the Hashicorp Vault and AWS External Secrets providers: ``` yaml {% include 'vault-jenkins-credential-github-ssh-access-external-secret.yaml' %} ``` ``` yaml {% include 'aws-jenkins-credential-github-ssh-external-secret.yaml' %} ```
Project: StarRocks (App Definition and Development / Database)
File: handbook.md

displayed_sidebar: "English" In general, you can build StarRocks by just executing ``` ./build.sh ``` This command will check if all the thirdpary dependencies are ready at first. If all dependencies are ready, it will build StarRocks `Backend` and `Frontend`. After this command executes succefully, the generated binary will be in `output` directory. You don't need to build both FE and BE each time, you can build them separately. For example, you can only build BE by ``` ./build.sh --be ``` and, only build FE by ``` ./build.sh --fe ``` Unit tests of BE and FE are separted. In general, you can run BE test by ``` ./run-be-ut.sh ``` run FE test by ``` ./run-fe-ut.sh ``` Now, BE UT needs some dependency to run, and `./run-be-ut.sh` helps it. But it is not flexible enough. When you want to run UT in the command-line, you can execute ``` UDFRUNTIMEDIR=./ STARROCKSHOME=./ LDLIBRARYPATH=/usr/lib/jvm/java-18-openjdk-amd64/lib/server ./be/utbuildASAN/test/starrockstest ``` StarRocks Backend UT is built on top of google-test, so you can pass filter to run some of the UT, For example, you want to test only MapColumn related tests, you can execute ``` UDFRUNTIMEDIR=./ STARROCKSHOME=./ LDLIBRARYPATH=/usr/lib/jvm/java-18-openjdk-amd64/lib/server ./be/utbuildASAN/test/starrockstest --gtest_filter="MapColumn" ``` You can build StarRocks by `clang` too ``` CC=clang CXX=clang++ ./build.sh --be ``` Then you can see the following similar message in the build message ``` -- compiler Clang version 14.0.0 ``` The default linker is slow, developer can specify different linker to speed up linking. For example, you can use `lld`, the LLVM-based linker. You need to install `lld` firstly. ``` sudo apt install lld ``` Then you set the environment variable STARROCKS_LINKER with the linker you want to use. For example: ``` STARROCKS_LINKER=lld ./build.sh --be ``` You can build StarRocks with different types with different BUILDTYPE variable, the default BUILDTYPE is `RELEASE`. For example, you can build StarRocks with `ASAN` type by ``` BUILD_TYPE=ASAN ./build.sh --be ```
Project: FOSSA (Provisioning / Security & Compliance)
File: npm.md

A `package.json` file is required to be present all types of npm analysis. Running `npm install` and generating a `package-lock.json` file will provide significantly better results. This allows FOSSA to detect the full dependency graph. Note: The `package-lock.json` file is expected to be located in the same directory as the `package.json` file. Directories containing `package.json` files are considered npm projects. `node_modules` subdirectories are skipped.
Project: KICS (Provisioning / Security & Compliance)
File: db78d14b-10e5-4e6e-84b1-dace6327b1ec.md

title: Group With Privilege Escalation By Actions 'iam:AttachUserPolicy' hide: toc: true navigation: true <style> .highlight .hll { background-color: #ff171742; } .md-content { max-width: 1100px; margin: 0 auto; } </style> Query id: db78d14b-10e5-4e6e-84b1-dace6327b1ec Query name: Group With Privilege Escalation By Actions 'iam:AttachUserPolicy' Platform: Terraform Severity: <span style="color:#ff7213">Medium</span> Category: Access Control URL: Group with privilege escalation by actions 'iam:AttachUserPolicy' and Resource set to '*'. For more information see https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/.<br> ```tf title="Positive test num. 1 - tf file" hl_lines="1" resource "awsiamgroup" "cosmic" { name = "cosmic" } resource "awsiamgrouppolicy" "testinline_policy" { name = "testinlinepolicy" group = awsiamgroup.cosmic.name policy = jsonencode({ Version = "2012-10-17" Statement = [ { Action = [ "iam:AttachUserPolicy", ] Effect = "Allow" Resource = "*" }, ] }) } ``` ```tf title="Negative test num. 1 - tf file" resource "awsiamuser" "cosmic2" { name = "cosmic2" } resource "awsiamuserpolicy" "inlinepolicyruninstances2" { name = "inlinepolicyrun_instances" user = awsiamuser.cosmic2.name policy = jsonencode({ Version = "2012-10-17" Statement = [ { Action = [ "ec2:Describe*", ] Effect = "Allow" Resource = "*" }, ] }) } ```
Project: ClickHouse (App Definition and Development / Database)
File: simpleaggregatefunction.md

slug: /en/sql-reference/data-types/simpleaggregatefunction sidebar_position: 48 sidebar_label: SimpleAggregateFunction `SimpleAggregateFunction(name, typesofarguments)` data type stores current value of the aggregate function, and does not store its full state as does. This optimization can be applied to functions for which the following property holds: the result of applying a function `f` to a row set `S1 UNION ALL S2` can be obtained by applying `f` to parts of the row set separately, and then again applying `f` to the results: `f(S1 UNION ALL S2) = f(f(S1) UNION ALL f(S2))`. This property guarantees that partial aggregation results are enough to compute the combined one, so we do not have to store and process any extra data. The common way to produce an aggregate function value is by calling the aggregate function with the suffix. The following aggregate functions are supported: :::note Values of the `SimpleAggregateFunction(func, Type)` look and stored the same way as `Type`, so you do not need to apply functions with `-Merge`/`-State` suffixes. `SimpleAggregateFunction` has better performance than `AggregateFunction` with same aggregation function. ::: Parameters Name of the aggregate function. Types of the aggregate function arguments. Example ``` sql CREATE TABLE simple (id UInt64, val SimpleAggregateFunction(sum, Double)) ENGINE=AggregatingMergeTree ORDER BY id; ```
Project: ShardingSphere (App Definition and Development / Database)
File: show-single-table.en.md

+++ title = "SHOW SINGLE TABLE" weight = 1 +++ The `SHOW SINGLE TABLE` syntax is used to query single tables for specified database. {{< tabs >}} {{% tab name="Grammar" %}} ```sql ShowSingleTable::= 'SHOW' 'SINGLE' ('TABLES' ('LIKES' likeLiteral)?|'TABLE' tableName) ('FROM' databaseName)? tableName ::= identifier databaseName ::= identifier ``` {{% /tab %}} {{% tab name="Railroad diagram" %}} <iframe frameborder="0" name="diagram" id="diagram" width="100%" height="100%"></iframe> {{% /tab %}} {{< /tabs >}} When `databaseName` is not specified, the default is the currently used `DATABASE`. If `DATABASE` is not used, `No database selected` will be prompted. | Column | Description | |-|| | table_name | Single table name | | storageunitname | The storage unit name where the single table is located | Query specified single table for specified database. ```sql SHOW SINGLE TABLE tuser FROM shardingdb; ``` ```sql mysql> SHOW SINGLE TABLE tuser FROM shardingdb; ++-+ | tablename | storageunit_name | ++-+ | tuser | ds0 | ++-+ 1 row in set (0.00 sec) ``` Query specified single table for current database. ```sql SHOW SINGLE TABLE t_user; ``` ```sql mysql> SHOW SINGLE TABLE t_user; ++-+ | tablename | storageunit_name | ++-+ | tuser | ds0 | ++-+ 1 row in set (0.00 sec) ``` Query single tables for specified database. ```sql SHOW SINGLE TABLES FROM sharding_db; ``` ```sql mysql> SHOW SINGLE TABLES FROM sharding_db; ++-+ | tablename | storageunit_name | ++-+ | tuser | ds0 | ++-+ 1 row in set (0.00 sec) ``` Query single tables for current database. ```sql SHOW SINGLE TABLES; ``` ```sql mysql> SHOW SINGLE TABLES; ++-+ | tablename | storageunit_name | ++-+ | tuser | ds0 | ++-+ 1 row in set (0.00 sec) ``` Query the single tables whose table name end with `order_5` for the specified logic database. ```sql SHOW SINGLE TABLES LIKE '%order5' FROM shardingdb; ``` ```sql mysql> SHOW SINGLE TABLES LIKE '%order5' FROM shardingdb; ++-+ | tablename | storageunit_name | ++-+ | torder5 | ds_1 | ++-+ 1 row in set (0.11 sec) ``` Query the single tables whose table name end with `order_5` for the current logic database ```sql SHOW SINGLE TABLES LIKE '%order_5'; ``` ```sql mysql> SHOW SINGLE TABLES LIKE '%order_5'; ++-+ | tablename | storageunit_name | ++-+ | torder5 | ds_1 | ++-+ 1 row in set (0.11 sec) ``` `SHOW`, `SINGLE`, `TABLE`, `TABLES`, `LIKE`, `FROM`
Project: Vald (App Definition and Development / Database)
File: feature_request.md

name: Feature request about: Suggest an idea for this project title: "" labels: "type/feature, priority/low, team/core" assignees: "" <!-- A clear and concise description of what the problem is. --> <!-- A clear and concise description of what you want to happen. --> <!-- A clear and concise description of any alternative solutions or features you've considered. -->
Project: Harbor (Provisioning / Container Registry)
File: 2-03-DB-user-push-multiple-projects.md

Test 2-03 - User Create Multiple Projects (DB Mode) ======= To verify that a non-admin user can create multiple projects when users are managed locally by Harbor (DB mode). User guide This test requires that a Harbor instance is running and available. Harbor is set to authenticate against a local database. ( auth_mode is set to db_auth* .) The user data is stored in a local database. A linux host with Docker CLI installed (Docker client). At least a non-admin user. NOTE: In below test, user A is non-admin user. User A should be replaced by a longer and meaningful name. Log in to UI as user A (non-admin). Create 16 or more projects so that the pagination control has multiple pages. Go through multiple pages of the list and click on a few projects to see if pagination work properly. Search projects with keywords to see if the list and pagination update accordingly. As described in step 3-4. None
Project: YugabyteDB (App Definition and Development / Database)
File: do-assert-bucket-ok.md

title: doassertbucket_ok linkTitle: doassertbucket_ok headerTitle: doassertbucket_ok.sql description: doassertbucket_ok.sql - Part of the code kit for the "Analyzing a normal distribution" section within the YSQL window functions documentation. menu: v2.18: identifier: do-assert-bucket-ok parent: analyzing-a-normal-distribution weight: 90 type: docs Save this script as `doassertbucket_ok.sql`. ```plpgsql -- Test it over the full range. -- Pay special attention to the bucket boundaries. do $body$ declare one constant int := 1; two constant int := 2; lower_bound constant double precision := 0; upper_bound constant double precision := 100; noofvalues constant int := 10; inputs constant double precision[] := array[ -- expected_bucket 0, -- 1 0.0000000001, -- 1 0.0000000002, -- 1 10, -- 1 10.00000001, 20, -- 2 20.00000001, 30, -- 3 30.00000001, 40, -- 4 40.00000001, 50, -- 5 50.00000001, 60, -- 6 60.00000001, 70, -- 7 70.00000001, 80, -- 8 80.00000001, 90, -- 9 90.00000001, 100 -- 10 ]; expected_buckets constant int[] := array[1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; begin for j in 1..array_upper(inputs, 1) loop declare expected_bucket constant int := expected_buckets[round((j + one)/two)::int]; begin assert bucket(inputs[j], lowerbound, upperbound, noofvalues) = expected_bucket, 'assert failed for test no. '||j::text||': bucket('||inputs[j]::text||', ...) <> '||expected_bucket::text; end; -- Provoke the expected assert failures from bucket(). declare result double precision not null := 0; begin begin result := bucket(-0.0000000002, lowerbound, upperbound, noofvalues); raise exception 'Logic error'; exception when assert_failure then -- raise info 'caught expected assert_failure'; null; end; begin result := bucket(100.0000000001, lowerbound, upperbound, noofvalues); raise exception 'Logic error'; exception when assert_failure then -- raise info 'caught expected assert_failure'; null; end; end; end loop; end; $body$; ```
Project: Chef InSpec (Provisioning / Security & Compliance)
File: windows_feature.md

+++ title = "windows_feature resource" draft = false gh_repo = "inspec" platform = "windows" [menu] [menu.inspec] title = "windows_feature" identifier = "inspec/resources/os/windowsfeature.md windowsfeature resource" parent = "inspec/resources/os" +++ Use the `windows_feature` Chef InSpec audit resource to test features on Windows via the `Get-WindowsFeature` cmdlet. {{< readfile file="content/inspec/reusable/md/inspec_installation.md" >}} This resource first became available in v1.0.0 of InSpec. A `windows_feature` resource block declares the name of the Windows feature, tests if that feature is installed, and then returns information about that feature: describe windowsfeature('featurename') do it { should be_installed } end where `('feature_name')` must specify a Windows feature name, such as `DHCP Server` or `IIS-Webserver` `be_installed` is a valid matcher for this resource The following examples show how to use this Chef InSpec audit resource. describe windows_feature('DHCP') do it{ should be_installed } end describe windows_feature('IIS-WebServer', DISM) do it{ should be_installed } end describe windows_feature('NetFx3', :dism) do it{ should be_installed } end {{< readfile file="content/inspec/reusable/md/inspecmatcherslink.md" >}} This resource has the following special matchers. The `be_installed` matcher tests if the named Windows feature is installed: it { should be_installed }
Project: KICS (Provisioning / Security & Compliance)
File: e4239438-e639-44aa-adb8-866e400e3ade.md

title: IAM Policy On User hide: toc: true navigation: true <style> .highlight .hll { background-color: #ff171742; } .md-content { max-width: 1100px; margin: 0 auto; } </style> Query id: e4239438-e639-44aa-adb8-866e400e3ade Query name: IAM Policy On User Platform: CloudFormation Severity: <span style="color:#ff7213">Medium</span> Category: Access Control URL: IAM policies should be applied to groups and not to users<br> ```yaml title="Positive test num. 1 - yaml file" hl_lines="11" Resources: BadPolicy: Type: AWS::IAM::Policy Properties: Description: Policy for something. Path: "/" PolicyDocument: Version: '2012-10-17' Statement: [] Users: Ref: TestUser ``` ```json title="Positive test num. 2 - json file" hl_lines="12" { "Resources": { "BadPolicy": { "Type": "AWS::IAM::Policy", "Properties": { "Description": "Policy for something.", "Path": "/", "PolicyDocument": { "Statement": [], "Version": "2012-10-17" }, "Users": [ { "Ref": "TestUser" } ] } } } } ``` ```yaml title="Negative test num. 1 - yaml file" Resources: GoodPolicy: Type: AWS::IAM::Policy Properties: Description: Policy for something. Path: "/" PolicyDocument: Version: '2012-10-17' Statement: [] Groups: user_group ``` ```json title="Negative test num. 2 - json file" { "Resources": { "GoodPolicy": { "Properties": { "Description": "Policy for something.", "Path": "/", "PolicyDocument": { "Version": "2012-10-17", "Statement": [] }, "Groups": [ "user_group" ] }, "Type": "AWS::IAM::Policy" } } } ```
Project: ThreatMapper (Provisioning / Security & Compliance)
File: splunk.md

title: Splunk ThreatMapper sends notifications to Splunk using HTTP Event Collector. Log in to splunk cloud platform and click "Add data" Choose HTTP Event Collector Copy endpoint URL and the generated token: https://SPLUNKCLOUDURL:8088/services/collector/event Configure Splunk integration in the Integrations page You can search for scan results now in Splunk
Project: Beam (App Definition and Development / Streaming & Messaging)
File: combineglobally.md

title: "CombineGlobally" <!-- Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. --> {{< localstorage language language-py >}} {{< button-pydoc path="apache_beam.transforms.core" class="CombineGlobally" >}} Combines all elements in a collection. See more information in the . In the following examples, we create a pipeline with a `PCollection` of produce. Then, we apply `CombineGlobally` in multiple ways to combine all the elements in the `PCollection`. `CombineGlobally` accepts a function that takes an `iterable` of elements as an input, and combines them to return a single element. We define a function `getcommonitems` which takes an `iterable` of sets as an input, and calculates the intersection (common items) of those sets. {{< playground height="700px" >}} {{< playgroundsnippet language="py" path="SDKPYTHONCombineGloballyFunction" show="combinegloballyfunction" >}} {{< /playground >}} We can also use lambda functions to simplify Example 1. {{< playground height="700px" >}} {{< playgroundsnippet language="py" path="SDKPYTHONCombineGloballyLambda" show="combinegloballylambda" >}} {{< /playground >}} You can pass functions with multiple arguments to `CombineGlobally`. They are passed as additional positional arguments or keyword arguments to the function. In this example, the lambda function takes `sets` and `exclude` as arguments. {{< playground height="700px" >}} {{< playgroundsnippet language="py" path="SDKPYTHONCombineGloballyMultipleArguments" show="combinegloballymultiple_arguments" >}} {{< /playground >}} The more general way to combine elements, and the most flexible, is with a class that inherits from `CombineFn`. : This creates an empty accumulator. For example, an empty accumulator for a sum would be `0`, while an empty accumulator for a product (multiplication) would be `1`. : Called once per element. Takes an accumulator and an input element, combines them and returns the updated accumulator. : Multiple accumulators could be processed in parallel, so this function helps merging them into a single accumulator. : It allows to do additional calculations before extracting a result. {{< playground height="700px" >}} {{< playgroundsnippet language="py" path="SDKPYTHONCombineGloballyCombineFn" show="combinegloballycombinefn" >}} {{< /playground >}} You can use the following combiner transforms: {{< button-pydoc path="apache_beam.transforms.core" class="CombineGlobally" >}}
Project: Meshery (Provisioning / Automation & Configuration)
File: mesheryctl-mesh-remove.md

layout: default title: mesheryctl-mesh-remove permalink: reference/mesheryctl/mesh/remove redirect_from: reference/mesheryctl/mesh/remove/ type: reference display-title: "false" language: en command: mesh subcommand: remove remove cloud and cloud native infrastructure remove cloud and cloud native infrastructure <pre class='codeblock-pre'> <div class='codeblock'> mesheryctl mesh remove [flags] </div> </pre> Remove Linkerd deployment <pre class='codeblock-pre'> <div class='codeblock'> mesheryctl mesh remove linkerd </div> </pre> Remove a Linkerd control plane found under a specific namespace (linkerd-ns) <pre class='codeblock-pre'> <div class='codeblock'> mesheryctl mesh remove linkerd --namespace linkerd-ns </div> </pre> <pre class='codeblock-pre'> <div class='codeblock'> </div> </pre> <pre class='codeblock-pre'> <div class='codeblock'> -h, --help help for remove -n, --namespace string Kubernetes namespace where the mesh is deployed (default "default") </div> </pre> <pre class='codeblock-pre'> <div class='codeblock'> --config string path to config file (default "/home/runner/.meshery/config.yaml") -t, --token string Path to token for authenticating to Meshery API -v, --verbose verbose output </div> </pre> Go back to , if you want to add content manually to the CLI documentation, please refer to the for guidance.
Project: YDB (App Definition and Development / Database)
File: storage_groups.md

A storage group is a redundant array of independent disks that are networked in a single logical unit. Storage groups increase fault tolerance through redundancy and improve performance. Each storage group corresponds to a specific storage schema that affects the number of disks used, the failure model, and the redundancy factor. The `block4-2` arrangement is commonly used for single-datacenter clusters with storage located on 8 disks in 8 racks and capable of surviving a failure of any two disks, and ensuring a redundancy factor of 1.5. Multiple-datacenter clusters use the `mirror3dc` arrangement with storage comprising 9 disks, 3 in each of the three datacenters, and capable of surviving a failure of a datacenter or disk and ensuring a redundancy factor of 3. {{ ydb-short-name }} lets you allocate additional storage groups for available DBs as your data grows.