cwielenb/CNCF-Dataset huggingface dataset:
Project: Pravega (App Definition and Development / Streaming & Messaging)
File: quick-start.md

<!-- Copyright Pravega Authors. 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 --> In one terminal, fetch the latest Pravega release: ``` wget https://github.com/pravega/pravega/releases/download/v0.12.0/pravega-0.12.0.tgz tar zxvf pravega-0.12.0.tgz cd pravega-0.12.0 ``` Launch Pravega in your first terminal: ``` ./bin/pravega-standalone ``` In another terminal, use the CLI tool to create a Scope and Stream: ``` ./bin/pravega-cli scope create my-scope stream create my-scope/my-stream ``` Append some events using your Pravega CLI session: ``` stream append my-scope/my-stream 5 ``` Read those events back in the same CLI session: ``` stream read my-scope/my-stream q ``` (press "q" and "Enter" to quit reading) Create a new stream, append some events with a routing key, and read them back: ``` stream create my-scope/ordered-stream stream append my-scope/ordered-stream my-routing-key 5 stream read my-scope/ordered-stream q ``` (press "q" and "Enter" to quit reading) In your second terminal, exit your `pravega-cli` session: ``` exit ``` In your first terminal, terminate the `pravega-standalone` server: ``` Ctrl+C ``` In completing this guide, you have launched Pravega, created a scope, created a couple streams, written ordered and unordered events to those streams, and read the events back from each stream. To use Pravega in real world applications, youll want to explore: , and .
Project: CyberArk Conjur (Provisioning / Key Management)
File: jekyll-structure.md

Conjur uses Jekyll for its static websites, including documentation and informational sites. This document is meant to outline the default structure and naming conventions for a Conjur Jekyll implementation so developers and designers can hit the ground quickly when editing an existing static site or creating a new one. Jekyll has a default directory structure which we use as a starting point. The main directories to keep in mind are: |Directory|Description|Filetype|Notes| ||||| | `./_data`|Contains files that house most of the static "data" the site uses.|`.yml`|Default structure.| | `./_deploy`|A custom directory containing scripts for development and deployment.|Various|Conjur custom.| |`./_site`|Static site generator output viewing and/or publishing.|Various|Default structure. Ignored by source. Consider these to be read-only.| |`./_includes`|Contains partials and snippets used for page templates and content.|`.md`|Default structure. Page-specific includes should go into sub-folders named appropriately.| |`./_includes/page-layout`|HTML structure includes used for modular page layout.|`.html`| | |`./_includes/partials`|HTML snippets used repeatedly.|`.html`| | |`./_layouts`|HTML templates for different page displays and display formats.|`.html`|Default structure.| |`./_plugins`|Directory for custom or 3rd-party Jekyll plugins.|`.rb`|Default structure. Optional.| |`./_sass`|SASS partials to be included in site generation.|`.scss`|Default structure.| |`css`|Statically hosted and served CSS files that are not SCSS.|One single main `.scss` file and other `.css` files.|Custom. Copied verbatim.| |`fonts`|Statically hosted and served font files.|Various.|Custom. Copied verbatim.| |`img`|Statically hosted and served images.|Various|Custom. Copied verbatim.| |`javascript`|Statically hosted and served JS files.|`.js`|Custom. Copied verbatim.| Other files and folders that live within the root directory where Jekyll is configured to check for source will be run through the generator. For more information, see Jeykll's documentation on . Custom directories that should be excluded from site generation (i.e. `_deploy`) should be prepended with an underscore. Custom files that should be excluded from site generation should be added to the `config.yml` file using the exclude_ syntax as shown in the . Static HTML files should use the extension `.html`. Files that will be processed into HTML files for the final site should use the extension `.md`. Partials or includes used in generated files should be prepended with an underscore (i.e. `_webservice.md`). File names should be spaced out using hyphens (`-`) so the final URL structure is sound and consistent. There is a lot of documentation, including other site structure examples, on the . When in doubt, go with the best practices and/or standards outlined in those docs.
Project: Druid (App Definition and Development / Database)
File: alerts.md

id: alerts title: "Alerts" <!-- ~ Licensed to the Apache Software Foundation (ASF) under one ~ or more contributor license agreements. See the NOTICE file ~ distributed with this work for additional information ~ regarding copyright ownership. The ASF licenses this file ~ to you 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. --> Druid generates alerts on getting into unexpected situations. Alerts are emitted as JSON objects to a runtime log file or over HTTP (to a service such as Apache Kafka). Alert emission is disabled by default. All Druid alerts share a common set of fields: `timestamp` - the time the alert was created `service` - the service name that emitted the alert `host` - the host name that emitted the alert `severity` - severity of the alert e.g. anomaly, component-failure, service-failure etc. `description` - a description of the alert `data` - if there was an exception then a JSON object with fields `exceptionType`, `exceptionMessage` and `exceptionStackTrace`
Project: Pravega (App Definition and Development / Streaming & Messaging)
File: releasenotes.md

<!-- Copyright Pravega Authors. 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. --> Find the release notes for the latest releases, packed with enhancements, fixes, and exciting features in our .
Project: StarRocks (App Definition and Development / Database)
File: FE_config_method.md

FE parameters are classified into dynamic parameters and static parameters. Dynamic parameters can be configured and adjusted by running SQL commands, which is very convenient. But the configurations become invalid if you restart your FE. Therefore, we recommend that you also modify the configuration items in the fe.conf file to prevent the loss of modifications. Static parameters can only be configured and adjusted in the FE configuration file fe.conf. After you modify this file, you must restart your FE for the changes to take effect. Whether a parameter is a dynamic parameter is indicated by the `IsMutable` column in the output of . `TRUE` indicates a dynamic parameter. Note that both dynamic and static FE parameters can be configured in the fe.conf file.
Project: TDengine (App Definition and Development / Database)
File: 12-google-data-studio.md

title: Use Google Data Studio to access TDengine sidebar_label: Google Data Studio description: This document describes how to integrate TDengine with Google Data Studio. Data Studio is a powerful tool for reporting and visualization, offering a wide variety of charts and connectors and making it easy to generate reports based on predefined templates. Its ease of use and robust ecosystem have made it one of the first choices for people working in data analysis. TDengine is a high-performance, scalable time-series database that supports SQL. Many businesses and developers in fields spanning from IoT and Industry Internet to IT and finance are using TDengine as their time-series database management solution. The TDengine team immediately saw the benefits of using TDengine to process time-series data with Data Studio to analyze it, and they got to work to create a connector for Data Studio. With the release of the TDengine connector in Data Studio, you can now get even more out of your data. To obtain the connector, first go to the Data Studio Connector Gallery, click Connect to Data, and search for "TDengine". Select the TDengine connector and click Authorize. Then sign in to your Google Account and click Allow to enable the connection to TDengine. In the Enter URL field, type the hostname and port of the server running the TDengine REST service. In the following fields, type your username, password, database name, table name, and the start and end times of your query range. Then, click Connect. After the connection is established, you can use Data Studio to process your data and create reports. In Data Studio, TDengine timestamps and tags are considered dimensions, and all other items are considered metrics. You can create all kinds of custom charts with your data - some examples are shown below. With the ability to process petabytes of data per day and provide monitoring and alerting in real time, TDengine is a great solution for time-series data management. Now, with the Data Studio connector, we're sure you'll be able to gain new insights and obtain even more value from your data.
Project: YugabyteDB (App Definition and Development / Database)
File: ddl_create_domain.md

title: CREATE DOMAIN statement [YSQL] headerTitle: CREATE DOMAIN linkTitle: CREATE DOMAIN description: Use the CREATE DOMAIN statement to create a user-defined data type with optional constraints. menu: v2.18: identifier: ddlcreatedomain parent: statements type: docs Use the `CREATE DOMAIN` statement to create a user-defined data type with optional constraints, such as range of valid values, `DEFAULT`, `NOT NULL`, and `CHECK`. Domains are useful to abstract data types with common constraints. For example, domain can be used to represent phone number columns that will require the same `CHECK` constraints on the syntax. {{%ebnf%}} create_domain, domain_constraint {{%/ebnf%}} Specify the name of the domain. An error is raised if `name` already exists in the specified database. Specify the underlying data type. Set the default value for columns of the domain data type. Specify the optional name for the constraint. Do not allow null values. Allow null values (default). Enforce a constraint that the values of the domain must satisfy and returns a Boolean value. The key word VALUE should be used to refer to the value being tested. Expressions evaluating to TRUE or UNKNOWN succeed. ```plpgsql yugabyte=# CREATE DOMAIN phone_number AS TEXT CHECK(VALUE ~ '^\d{3}-\d{3}-\d{4}$'); ``` ```plpgsql yugabyte=# CREATE TABLE person(firstname TEXT, lastname TEXT, phonenumber phonenumber); ```
Project: Tetragon (Provisioning / Security & Compliance)
File: README.md

](https://travis-ci.org/kubernetes-sigs/yaml) kubernetes-sigs/yaml is a permanent fork of . A wrapper around designed to enable a better way of handling YAML when marshaling to and from structs. In short, this library first converts YAML to JSON using go-yaml and then uses `json.Marshal` and `json.Unmarshal` to convert to or from the struct. This means that it effectively reuses the JSON struct tags as well as the custom JSON methods `MarshalJSON` and `UnmarshalJSON` unlike go-yaml. For a detailed overview of the rationale behind this method, . This package uses and therefore supports . Caveat #1: When using `yaml.Marshal` and `yaml.Unmarshal`, binary data should NOT be preceded with the `!!binary` YAML tag. If you do, go-yaml will convert the binary data from base64 to native binary data, which is not compatible with JSON. You can still use binary in your YAML files though - just store them without the `!!binary` tag and decode the base64 in your code (e.g. in the custom JSON methods `MarshalJSON` and `UnmarshalJSON`). This also has the benefit that your YAML and your JSON binary data will be decoded exactly the same way. As an example: ``` BAD: exampleKey: !!binary gIGC GOOD: exampleKey: gIGC ... and decode the base64 data in your code. ``` Caveat #2: When using `YAMLToJSON` directly, maps with keys that are maps will result in an error since this is not supported by JSON. This error will occur in `Unmarshal` as well since you can't unmarshal map keys anyways since struct fields can't be keys. To install, run: ``` $ go get sigs.k8s.io/yaml ``` And import using: ``` import "sigs.k8s.io/yaml" ``` Usage is very similar to the JSON library: ```go package main import ( "fmt" "sigs.k8s.io/yaml" ) type Person struct { Name string `json:"name"` // Affects YAML field names too. Age int `json:"age"` } func main() { // Marshal a Person struct to YAML. p := Person{"John", 30} y, err := yaml.Marshal(p) if err != nil { fmt.Printf("err: %v\n", err) return } fmt.Println(string(y)) /* Output: age: 30 name: John */ // Unmarshal the YAML back into a Person struct. var p2 Person err = yaml.Unmarshal(y, &p2) if err != nil { fmt.Printf("err: %v\n", err) return } fmt.Println(p2) /* Output: {John 30} */ } ``` `yaml.YAMLToJSON` and `yaml.JSONToYAML` methods are also available: ```go package main import ( "fmt" "sigs.k8s.io/yaml" ) func main() { j := []byte(`{"name": "John", "age": 30}`) y, err := yaml.JSONToYAML(j) if err != nil { fmt.Printf("err: %v\n", err) return } fmt.Println(string(y)) /* Output: age: 30 name: John */ j2, err := yaml.YAMLToJSON(y) if err != nil { fmt.Printf("err: %v\n", err) return } fmt.Println(string(j2)) /* Output: {"age":30,"name":"John"} */ } ```
Project: SOPS (Provisioning / Security & Compliance)
File: CONTRIBUTING.md

The SOPS project welcomes contributions from everyone. Here are a few guidelines and instructions if you are thinking of helping with the development of SOPS. Make sure you have Go 1.19 or greater installed. You can find information on how to install Go Clone the Git repository and switch into SOPS's directory. Run the tests with `make test`. They should all pass. If you modify documentation (RST or MD files), run `make checkdocs` to run and . These should also pass. If you need help in fixing issues, create a pull request (see below) and ask for help. Fork the project on GitHub. Add your fork to Git's remotes: If you use SSH authentication: `git remote add <your username> git@github.com:<your username>/sops.git`. Otherwise: `git remote add <your username> https://github.com/<your username>/sops.git`. Make any changes you want to SOPS, commit them, and push them to your fork. Create a pull request against `main`, and a maintainer will come by and review your code. They may ask for some changes, and hopefully your contribution will be merged! Unless it's particularly hard, changes that fix a bug should have a regression test to make sure that the bug is not introduced again. New features and changes to existing features should be documented, and, if possible, tested. If you need any help contributing to SOPS, several maintainers are on the on the .
Project: YugabyteDB (App Definition and Development / Database)
File: dml_truncate.md

title: TRUNCATE statement [YCQL] headerTitle: TRUNCATE linkTitle: TRUNCATE description: Use the TRUNCATE statement to remove all rows from a specified table. menu: v2.18: parent: api-cassandra weight: 1330 type: docs Use the `TRUNCATE` statement to remove all rows from a specified table. <svg class="rrdiagram" version="1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns="http://www.w3.org/2000/svg" width="303" height="50" viewbox="0 0 303 50"><path class="connector" d="M0 22h5m84 0h30m58 0h20m-93 0q5 0 5 5v8q0 5 5 5h68q5 0 5-5v-8q0-5 5-5m5 0h10m91 0h5"/><rect class="literal" x="5" y="5" width="84" height="25" rx="7"/><text class="text" x="15" y="22">TRUNCATE</text><rect class="literal" x="119" y="5" width="58" height="25" rx="7"/><text class="text" x="129" y="22">TABLE</text><a xlink:href="../grammardiagrams#table-name"><rect class="rule" x="207" y="5" width="91" height="25"/><text class="text" x="217" y="22">tablename</text></a></svg> ```ebnf truncate ::= TRUNCATE [ TABLE ] table_name; ``` Where `table_name` is an identifier (possibly qualified with a keyspace name). An error is raised if the specified `table_name` does not exist. ```sql ycqlsh:example> CREATE TABLE employees(department_id INT, employee_id INT, name TEXT, PRIMARY KEY(departmentid, employeeid)); ``` ```sql ycqlsh:example> INSERT INTO employees(departmentid, employeeid, name) VALUES (1, 1, 'John'); ``` ```sql ycqlsh:example> INSERT INTO employees(departmentid, employeeid, name) VALUES (1, 2, 'Jane'); ``` ```sql ycqlsh:example> INSERT INTO employees(departmentid, employeeid, name) VALUES (2, 1, 'Joe'); ``` ```sql ycqlsh:example> SELECT * FROM employees; ``` ```output departmentid | employeeid | name +-+ 2 | 1 | Joe 1 | 1 | John 1 | 2 | Jane ``` Remove all rows from the table. ```sql ycqlsh:example> TRUNCATE employees; ``` ```sql ycqlsh:example> SELECT * FROM employees; ``` ```output departmentid | employeeid | name +-+ ```
Project: Backstage (App Definition and Development / Application Definition & Image Build)
File: scheduler.md

id: scheduler title: Scheduler Service sidebar_label: Scheduler description: Documentation for the Scheduler service When writing plugins, you sometimes want to have things running on a schedule, or something similar to cron jobs that are distributed through instances that your backend plugin is running on. We supply a task scheduler for this purpose that is scoped per plugin so that you can create these tasks and orchestrate their execution. The following example shows how to get the scheduler service in your `example` backend to issue a scheduled task that runs across your instances at a given interval. ```ts import { coreServices, createBackendPlugin, } from '@backstage/backend-plugin-api'; import { fetch } from 'node-fetch'; createBackendPlugin({ pluginId: 'example', register(env) { env.registerInit({ deps: { scheduler: coreServices.scheduler, }, async init({ scheduler }) { await scheduler.scheduleTask({ frequency: { minutes: 10 }, timeout: { seconds: 30 }, id: 'ping-google', fn: async () => { await fetch('http://google.com/ping'); }, }); }, }); }, }); ```
Project: Pravega (App Definition and Development / Streaming & Messaging)
File: join-community.md

<!-- Copyright Pravega Authors. 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. -->
Project: KICS (Provisioning / Security & Compliance)
File: f118890b-2468-42b1-9ce9-af35146b425b.md

title: MySQL Server Public Access Enabled hide: toc: true navigation: true <style> .highlight .hll { background-color: #ff171742; } .md-content { max-width: 1100px; margin: 0 auto; } </style> Query id: f118890b-2468-42b1-9ce9-af35146b425b Query name: MySQL Server Public Access Enabled Platform: Terraform Severity: <span style="color:#bb2124">High</span> Category: Networking and Firewall URL: MySQL Server public access should be disabled<br> ```tf title="Positive test num. 1 - tf file" hl_lines="1" resource "azurermmysqlserver" "positive1" { name = "example-mysqlserver" location = azurermresourcegroup.example.location resourcegroupname = azurermresourcegroup.example.name administrator_login = "mysqladminun" administratorloginpassword = "H@Sh1CoR3!" skuname = "BGen5_2" storage_mb = 5120 version = "5.7" autogrowenabled = true backupretentiondays = 7 georedundantbackup_enabled = false infrastructureencryptionenabled = false sslenforcementenabled = true sslminimaltlsversionenforced = "TLS1_2" } ``` ```tf title="Positive test num. 2 - tf file" hl_lines="17" resource "azurermmysqlserver" "positive2" { name = "example-mysqlserver" location = azurermresourcegroup.example.location resourcegroupname = azurermresourcegroup.example.name administrator_login = "mysqladminun" administratorloginpassword = "H@Sh1CoR3!" skuname = "BGen5_2" storage_mb = 5120 version = "5.7" autogrowenabled = true backupretentiondays = 7 georedundantbackup_enabled = false infrastructureencryptionenabled = false publicnetworkaccess_enabled = true sslenforcementenabled = true sslminimaltlsversionenforced = "TLS1_2" } ``` ```tf title="Negative test num. 1 - tf file" resource "azurermmysqlserver" "negative" { name = "example-mysqlserver" location = azurermresourcegroup.example.location resourcegroupname = azurermresourcegroup.example.name administrator_login = "mysqladminun" administratorloginpassword = "H@Sh1CoR3!" skuname = "BGen5_2" storage_mb = 5120 version = "5.7" autogrowenabled = true backupretentiondays = 7 georedundantbackup_enabled = false infrastructureencryptionenabled = false publicnetworkaccess_enabled = false sslenforcementenabled = true sslminimaltlsversionenforced = "TLS1_2" } ```
Project: KubeBlocks by ApeCloud (App Definition and Development / Database)
File: kbcli_dataprotection.md

title: kbcli dataprotection Data protection command. ``` -h, --help help for dataprotection ``` ``` --as string Username to impersonate for the operation. User could be a regular user or a service account in a namespace. --as-group stringArray Group to impersonate for the operation, this flag can be repeated to specify multiple groups. --as-uid string UID to impersonate for the operation. --cache-dir string Default cache directory (default "$HOME/.kube/cache") --certificate-authority string Path to a cert file for the certificate authority --client-certificate string Path to a client certificate file for TLS --client-key string Path to a client key file for TLS --cluster string The name of the kubeconfig cluster to use --context string The name of the kubeconfig context to use --disable-compression If true, opt-out of response compression for all requests to the server --insecure-skip-tls-verify If true, the server's certificate will not be checked for validity. This will make your HTTPS connections insecure --kubeconfig string Path to the kubeconfig file to use for CLI requests. --match-server-version Require server version to match client version -n, --namespace string If present, the namespace scope for this CLI request --request-timeout string The length of time to wait before giving up on a single server request. Non-zero values should contain a corresponding time unit (e.g. 1s, 2m, 3h). A value of zero means don't timeout requests. (default "0") -s, --server string The address and port of the Kubernetes API server --tls-server-name string Server name to use for server certificate validation. If it is not provided, the hostname used to contact the server is used --token string Bearer token for authentication to the API server --user string The name of the kubeconfig user to use ``` - Create a backup for the cluster. - Delete a backup. - Describe a backup - Describe a backup policy - List backup policies - List backups. - Restore a new cluster from backup