cwielenb/CNCF-Dataset huggingface dataset:
Project: EDB (App Definition and Development / Database)
File: declarative_hibernation.md

CloudNativePG is designed to keep PostgreSQL clusters up, running and available anytime. There are some kinds of workloads that require the database to be up only when the workload is active. Batch-driven solutions are one such case. In batch-driven solutions, the database needs to be up only when the batch process is running. The declarative hibernation feature enables saving CPU power by removing the database Pods, while keeping the database PVCs. !!! Note Declarative hibernation is different from the existing implementation of . Imperative hibernation shuts down all Postgres instances in the High Availability cluster, and keeps a static copy of the PVCs of the primary that contain `PGDATA` and WALs. The plugin enables to exit the hibernation phase, by resuming the primary and then recreating all the replicas - if they exist. To hibernate a cluster, set the `cnpg.io/hibernation=on` annotation: ``` sh $ kubectl annotate cluster <cluster-name> --overwrite cnpg.io/hibernation=on ``` A hibernated cluster won't have any running Pods, while the PVCs are retained so that the cluster can be rehydrated at a later time. Replica PVCs will be kept in addition to the primary's PVC. The hibernation procedure will delete the primary Pod and then the replica Pods, avoiding switchover, to ensure the replicas are kept in sync. The hibernation status can be monitored by looking for the `cnpg.io/hibernation` condition: ``` sh $ kubectl get cluster <cluster-name> -o "jsonpath={.status.conditions[?(.type==\"cnpg.io/hibernation\")]}" { "lastTransitionTime":"2023-03-05T16:43:35Z", "message":"Cluster has been hibernated", "reason":"Hibernated", "status":"True", "type":"cnpg.io/hibernation" } ``` The hibernation status can also be read with the `status` sub-command of the `cnpg` plugin for `kubectl`: ``` sh $ kubectl cnpg status <cluster-name> Cluster Summary Name: cluster-example Namespace: default PostgreSQL Image: ghcr.io/cloudnative-pg/postgresql:16.2 Primary instance: cluster-example-2 Status: Cluster in healthy state Instances: 3 Ready instances: 0 Hibernation Status Hibernated Message Cluster has been hibernated Time 2023-03-05 16:43:35 +0000 UTC [..] ``` To rehydrate a cluster, either set the `cnpg.io/hibernation` annotation to `off`: ``` $ kubectl annotate cluster <cluster-name> --overwrite cnpg.io/hibernation=off ``` Or, just unset it altogether: ``` $ kubectl annotate cluster <cluster-name> cnpg.io/hibernation- ``` The Pods will be recreated and the cluster will resume operation.
Project: Chef InSpec (Provisioning / Security & Compliance)
File: ibmdb2_session.md

+++ title = "ibmdb2_session resource" draft = false gh_repo = "inspec" platform = "os" [menu] [menu.inspec] title = "ibmdb2_session" identifier = "inspec/resources/os/ibmdb2session.md ibmdb2session resource" parent = "inspec/resources/os" +++ Use the `ibmdb2_session` Chef InSpec audit resource to test SQL commands run against an IBM Db2 database. Make sure you are using the IBM Db2 database instance user credentials to run the InSpec test. {{< readfile file="content/inspec/reusable/md/inspec_installation.md" >}} A `ibmdb2session` resource block declares the db2executablefilepath, dbinstance and dbname to use for the session, and then the query to be run: describe ibmdb2session(db2executablefilepath: "/opt/ibm/db2/V11.5/bin/db2", dbinstance: "db2inst1", dbname: "sample").query("select rolename from syscat.roleauth") do its("output") { should match(/SYSTS_MGR/) } end Windows describe ibmdb2session(dbname: "sample").query("select rolename from syscat.roleauth") do its("output") { should match(/SYSTS_MGR/) } end where `ibmdb2session` declares a db2executablefilepath, dbinstance and dbname to connect. `db2executablefile_path` is the path of the db2 binary file. For Windows this is not required. `db_instance` is the name of the database instance. For Windows this is not required. `db_name` is the name of the database to query on. `query('QUERY')` contains the query to be run. `its('output') { should eq(/expected-result/) }` compares the results of the query against the expected result in the test. The following examples show how to use this Chef InSpec audit resource. describe ibmdb2session(db2executablefilepath: "/opt/ibm/db2/V11.5/bin/db2", dbinstance: "db2inst1", dbname: "sample").query("select rolename from syscat.roleauth") do its("output") { should match(/SYSTS_MGR/) } end describe ibmdb2session(db2executablefilepath: "/opt/ibm/db2/V11.5/bin/db2", dbinstance: "db2inst1", dbname: "sample").query("list database directory") do its("output") { should match(/SAMPLE/) } end {{< readfile file="content/inspec/reusable/md/inspecmatcherslink.md" >}}
Project: ShardingSphere (App Definition and Development / Database)
File: commiter_rights.en.md

+++ title = "Committer Rights" weight = 5 chapter = true +++ Every Apache Committer is eligible for a free license that grants them access to all the JetBrains IDEs such as IntelliJ IDEA, PyCharm, and other desktop tools. If you are an Apache ShardingSphere Committer and still havent received a free JetBrains license, please use your @apache.org email address to for the subsequent development of ShardingSphere. If you have obtained a free JetBrains subscription but it has expired, you can reactivate all product packs for free using your @apache.org email address and click 'Refresh license list' in your JetBrains desktop tools (e.g. IntelliJ IDEA) to refresh the subscription.
Project: Chef InSpec (Provisioning / Security & Compliance)
File: google_service_accounts.md

+++ title = "googleserviceaccounts resource" draft = false gh_repo = "inspec" platform = "gcp" [menu] [menu.inspec] title = "googleserviceaccounts" identifier = "inspec/resources/gcp/googleserviceaccounts.md googleserviceaccounts resource" parent = "inspec/resources/gcp" +++ A `googleserviceaccounts` is used to test a Google ServiceAccount resource ```ruby describe googleserviceaccounts(project: 'chef-gcp-inspec', name: "display-name@project-id.iam.gserviceaccount.com") do its('serviceaccountemails') { should include "display-name@project-id.iam.gserviceaccount.com" } its('count') { should be <= 1000 } end ``` describe googleserviceaccounts(project: 'chef-inspec-gcp') do its('count') { should be <= 1000} end describe googleserviceaccounts(project: 'chef-inspec-gcp') do its('serviceaccountdisplaynames'){ should include "gcpsa_name" } end describe googleserviceaccounts(project: 'chef-inspec-gcp') do its('serviceaccountids'){ should include 12345678 } end describe googleserviceaccounts(project: 'dummy-project') do its('serviceaccountnames'){ should include "projects/dummy-project/serviceAccounts/dummy-acct@dummy-project.iam.gserviceaccount.com" } end googleserviceaccounts(project: 'chef-inspec-gcp').where(serviceaccountdisplaynames: /^dummyaccount/).serviceaccountnames.each do |saname| describe googleserviceaccount(name: sa_name) do it { should exist } end end Properties that can be accessed from the `googleserviceaccounts` resource: See the resource for more information. `serviceaccountnames` : an array of `googleserviceaccount` name `project_ids` : an array of `googleserviceaccount` project_id `serviceaccountids` : an array of `googleserviceaccount` unique_id `serviceaccountemails` : an array of `googleserviceaccount` email `serviceaccountdisplay_names` : an array of `googleserviceaccount` display_name `oauth2clientids` : an array of `googleserviceaccount` oauth2clientid This resource supports all of the above properties as filter criteria, which can be used with `where` as a block or a method. Ensure the is enabled for the current project.
Project: Kui (App Definition and Development / Application Definition & Image Build)
File: kui_shell_plugin_kubectl.Secret.md

/ / Secret .Secret Kubernetes Secret | Name | Type | | : | :- | | `T` | `Record`<`string`, `any`\> | `Secret` apiVersion: `"v1"` KubeResource.apiVersion `Optional` content: `void` KubeResource.content packages/core/mdist/models/entity.d.ts:50 `Optional` contentType: `string` KubeResource.contentType packages/core/mdist/models/entity.d.ts:51 data: `T` isKubeResource: `true` KubeResource.isKubeResource `Optional` isSimulacrum: `boolean` KubeResource.isSimulacrum kind: `"Secret"` KubeResource.kind `Optional` kuiRawData: `string` KubeResource.kuiRawData `Optional` metadata: { `creationTimestamp?`: `string` ; `generation?`: `string` ; `labels?`: `Record`<`string`, `string`\> ; `name`: `string` ; `namespace?`: `string` } & `Partial`<`WithOwnerReferences`\> & `Partial`<`WithResourceVersion`\> & { `annotations?`: `object` ; `creationTimestamp?`: `string` ; `generateName?`: `string` ; `generation?`: `string` ; `labels?`: { [key: string]: `string`; } ; `name`: `string` ; `namespace?`: `string` ; `uid?`: `string` } KubeResource.metadata packages/core/mdist/models/entity.d.ts:23 `Optional` nameHash: `string` KubeResource.nameHash packages/core/mdist/models/entity.d.ts:42 `Optional` onclick: `Object` family of onclick handlers | Name | Type | | :-- | :- | | `kind?` | `string` | | `name?` | `string` | | `nameHash?` | `string` | | `namespace?` | `string` | KubeResource.onclick packages/core/mdist/models/entity.d.ts:44 originatingCommand: `EvaluatorArgs`<\> KubeResource.originatingCommand `Optional` presentation: `Presentation` KubeResource.presentation packages/core/mdist/models/entity.d.ts:53 `Optional` prettyName: `string` name hash, e.g. the hash part of auto-generated names, or an openwhisk activation id KubeResource.prettyName packages/core/mdist/models/entity.d.ts:41 `Optional` spec: `any` KubeResource.spec `Optional` status: KubeResource.status `Optional` toolbarText: `ToolbarText` KubeResource.toolbarText packages/core/mdist/models/entity.d.ts:52 type: `string` `Optional` version: `string` optional designation of resource version KubeResource.version packages/core/mdist/models/entity.d.ts:39
Project: EMQ Technologies (App Definition and Development / Streaming & Messaging)
File: fix-12714.en.md

Fixed some field errors in prometheus api `/prometheus/stats`. Related metrics names: `emqxclustersessions_count` `emqxclustersessions_max` `emqxclusternodes_running` `emqxclusternodes_stopped` `emqxsubscriptionsshared_count` `emqxsubscriptionsshared_max` Fixed the issue in endpoint: `/stats` that the values of fields `subscriptions.shared.count` and `subscriptions.shared.max` can not be updated in time when the client disconnected or unsubscribed the Shared-Subscription.
Project: CDK for Kubernetes (CDK8s) (Provisioning / Automation & Configuration)
File: rfc.md

name: RFC about: Propose a significant change to the cdk8s toolchain title: RFC | describe your RFC labels: rfc/proposed assignees: '' Short description of the proposed feature. | Role | User || | Proposed by | @alias | Author(s) | @alias, @alias, @alias | API Bar Raiser | @alias | Stakeholders | @alias, @alias, @alias See for details [x] Tracking issue created (label: `rfc/proposed`) if needed) [ ] Kick off meeting [ ] RFC pull request submitted (label: `rfc/review`) [ ] Community reach out (via Slack and/or Twitter) [ ] API signed-off (label `rfc/api-approved` applied to pull request) [ ] Final comments period (label: `rfc/final-comments-period`) [ ] Approved and merged (label: `rfc/approved`) [ ] Execution plan submitted (label: `rfc/planning`) [ ] Plan approved and merged (label: `rfc/implementing`) [ ] Implementation complete (label: `rfc/done`) Author is responsible to progress the RFC according to this checklist, and apply the relevant labels to this issue so that the RFC table in README gets updated.
Project: ClickHouse (App Definition and Development / Database)
File: composable-protocols.md

slug: /en/operations/settings/composable-protocols sidebar_position: 64 sidebar_label: Composable Protocols Composable protocols allows more flexible configuration of TCP access to the ClickHouse server. This configuration can co-exist with or replace conventional configuration. Example: ``` xml <protocols> </protocols> ``` Example: ``` xml <protocols> <!-- plain_http module --> <plain_http> <type>http</type> </plain_http> </protocols> ``` where: `plain_http` - name which can be referred by another layer `type` - denotes protocol handler which will be instantiated to process data, set of protocol handlers is predefined: `tcp` - native clickhouse protocol handler `http` - http clickhouse protocol handler `tls` - TLS encryption layer `proxy1` - PROXYv1 layer `mysql` - MySQL compatibility protocol handler `postgres` - PostgreSQL compatibility protocol handler `prometheus` - Prometheus protocol handler `interserver` - clickhouse interserver handler :::note `gRPC` protocol handler is not implemented for `Composable protocols` ::: Example: ``` xml <protocols> <plain_http> <type>http</type> <!-- endpoint --> <host>127.0.0.1</host> <port>8123</port> </plain_http> </protocols> ``` If `<host>` is omitted, then `<listen_host>` from root config is used. Example: definition for HTTPS protocol ``` xml <protocols> <!-- http module --> <plain_http> <type>http</type> </plain_http> <!-- https module configured as a tls layer on top of plain_http module --> <https> <type>tls</type> <impl>plain_http</impl> <host>127.0.0.1</host> <port>8443</port> </https> </protocols> ``` Example: definition for HTTP (port 8123) and HTTPS (port 8443) endpoints ``` xml <protocols> <plain_http> <type>http</type> <host>127.0.0.1</host> <port>8123</port> </plain_http> <https> <type>tls</type> <impl>plain_http</impl> <host>127.0.0.1</host> <port>8443</port> </https> </protocols> ``` Example: `anotherhttp` endpoint is defined for `plainhttp` module ``` xml <protocols> <plain_http> <type>http</type> <host>127.0.0.1</host> <port>8123</port> </plain_http> <https> <type>tls</type> <impl>plain_http</impl> <host>127.0.0.1</host> <port>8443</port> </https> <another_http> <impl>plain_http</impl> <host>127.0.0.1</host> <port>8223</port> </another_http> </protocols> ``` Example: for TLS layer private key (`privateKeyFile`) and certificate files (`certificateFile`) can be specified ``` xml <protocols> <plain_http> <type>http</type> <host>127.0.0.1</host> <port>8123</port> </plain_http> <https> <type>tls</type> <impl>plain_http</impl> <host>127.0.0.1</host> <port>8443</port> <privateKeyFile>another_server.key</privateKeyFile> <certificateFile>another_server.crt</certificateFile> </https> </protocols> ```
Project: YDB (App Definition and Development / Database)
File: data-type-literals.md

For primitive types, you can create literals based on string literals. Syntax `<Primitive type>( <string>[, <additional attributes>] )` Unlike `CAST("myString" AS MyType)`: The check for literal's castability to the desired type occurs at validation. The result is non-optional. For the data types `Date`, `Datetime`, `Timestamp`, and `Interval`, literals are supported only in the format corresponding to . `Interval` has the following differences from the standard: It supports the negative sign for shifts to the past. Microseconds can be expressed as fractional parts of seconds. You can't use units of measurement exceeding one week. The options with the beginning/end of the interval and with repetitions, are not supported. For the data types `TzDate`, `TzDatetime`, `TzTimestamp`, literals are also set in the format meeting , but instead of the optional Z suffix, they specify the , separated by comma (for example, GMT or Europe/Moscow). {% include %} Examples ```yql SELECT Bool("true"), Uint8("0"), Int32("-1"), Uint32("2"), Int64("-3"), Uint64("4"), Float("-5"), Double("6"), Decimal("1.23", 5, 2), -- up to 5 decimal digits, with 2 after the decimal point String("foo"), Utf8("Hello"), Yson("<a=1>[3;%false]"), Json(@@{"a":1,"b":null}@@), Date("2017-11-27"), Datetime("2017-11-27T13:24:00Z"), Timestamp("2017-11-27T13:24:00.123456Z"), Interval("P1DT2H3M4.567890S"), TzDate("2017-11-27,Europe/Moscow"), TzDatetime("2017-11-27T13:24:00,America/Los_Angeles"), TzTimestamp("2017-11-27T13:24:00.123456,GMT"), Uuid("f9d5cc3f-f1dc-4d9c-b97e-766e57ca4ccb"); ```
Project: Beam (App Definition and Development / Streaming & Messaging)
File: values.md

title: "Values" <!-- 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.util" class="Values" >}} Takes a collection of key-value pairs, and returns the value of each element. In the following example, we create a pipeline with a `PCollection` of key-value pairs. Then, we apply `Values` to extract the values and discard the keys. {{< playground height="700px" >}} {{< playgroundsnippet language="py" path="SDKPYTHON_Values" show="values" >}} {{< /playground >}} for extracting the key of each component. swaps the key and value of each element. {{< button-pydoc path="apache_beam.transforms.util" class="Values" >}}
Project: SeaTunnel (App Definition and Development / Streaming & Messaging)
File: JobEnvConfig.md

This document describes env configuration information, the common parameters can be used in all engines. In order to better distinguish between engine parameters, the additional parameters of other engine need to carry a prefix. In flink engine, we use `flink.` as the prefix. In the spark engine, we do not use any prefixes to modify parameters, because the official spark parameters themselves start with `spark.` The following configuration parameters are common to all engines This parameter configures the task name. Third-party packages can be loaded via `jars`, like `jars="file://local/jar1.jar;file://local/jar2.jar"` You can configure whether the task is in batch mode or stream mode through `job.mode`, like `job.mode = "BATCH"` or `job.mode = "STREAMING"` Gets the interval in which checkpoints are periodically scheduled. In `STREAMING` mode, checkpoints is required, if you do not set it, it will be obtained from the application configuration file `seatunnel.yaml`. In `BATCH` mode, you can disable checkpoints by not setting this parameter. This parameter configures the parallelism of source and sink. Used to control the default retry times when a job fails. The default value is 3, and it only works in the Zeta engine. Specify the method of encryption, if you didn't have the requirement for encrypting or decrypting config files, this option can be ignored. For more details, you can refer to the documentation Here are some SeaTunnel parameter names corresponding to the names in Flink, not all of them, please refer to the official for more. | Flink Configuration Name | SeaTunnel Configuration Name | ||| | pipeline.max-parallelism | flink.pipeline.max-parallelism | | execution.checkpointing.mode | flink.execution.checkpointing.mode | | execution.checkpointing.timeout | flink.execution.checkpointing.timeout | | ... | ... | Because spark configuration items have not been modified, they are not listed here, please refer to the official .
Project: Chef InSpec (Provisioning / Security & Compliance)
File: google_container_regional_node_pools.md

+++ title = "googlecontainerregionalnodepools resource" draft = false gh_repo = "inspec" platform = "gcp" [menu] [menu.inspec] title = "googlecontainerregionalnodepools" identifier = "inspec/resources/gcp/googlecontainerregionalnodepools.md googlecontainerregionalnodepools resource" parent = "inspec/resources/gcp" +++ A `googlecontainerregionalnodepools` is used to test a Google RegionalNodePool resource ```ruby describe googlecontainerregionalnodepools(project: 'chef-gcp-inspec', location: 'europe-west2', cluster: 'inspec-gcp-regional-cluster') do its('initialnodecounts') { should include '1'} end ``` Properties that can be accessed from the `googlecontainerregionalnodepools` resource: See the resource for more information. `names` : an array of `googlecontainerregionalnodepool` name `configs` : an array of `googlecontainerregionalnodepool` config `initialnodecounts` : an array of `googlecontainerregionalnodepool` initialnodecount `statuses` : an array of `googlecontainerregionalnodepool` status `status_messages` : an array of `googlecontainerregionalnodepool` status_message `versions` : an array of `googlecontainerregionalnodepool` version `autoscalings` : an array of `googlecontainerregionalnodepool` autoscaling `managements` : an array of `googlecontainerregionalnodepool` management `maxpodsconstraints` : an array of `googlecontainerregionalnodepool` maxpodsconstraint `conditions` : an array of `googlecontainerregionalnodepool` conditions `podipv4cidr_sizes` : an array of `googlecontainerregionalnodepool` podipv4cidr_size `clusters` : an array of `googlecontainerregionalnodepool` cluster `locations` : an array of `googlecontainerregionalnodepool` location This resource supports all of the above properties as filter criteria, which can be used with `where` as a block or a method. Ensure the is enabled for the current project.
Project: Cyclops (App Definition and Development / Application Definition & Image Build)
File: new_module.md

Now that your Cyclops instance is deployed locally, you can deploy an application into the cluster through Cyclops. When you start up Cyclops, the first screen shown to you is the Modules screen. This screen should be empty at the moment. What we want to do next is click on the Add module button in the top right corner. Now, we want to define our new module. Every Cyclops instance comes with a couple of predefined templates, which we included. From the dropdown under Module template, you can choose which predefined templates you want to use. For the sake of this tutorial, we will use `demo-template`. If you want to learn more about templates and how to create your own, check out the ! If you play around with different templates, you will find that Cyclops is highly customizable. Depending on the template used, this screen will be different. Now, all left to do is fill the form with values and click Save! Here is an example of values you could use: ```yaml Module name: demo name: demo-1 replicas: 3 image: nginx version: 1.14.2 service: true ``` Once you have deployed your application, you will be taken to a new page to find the overview of all the resources your new module uses. If you have tried out Cyclops with the suggested template and values, you can open your deployed application by exposing it to the outside world and visiting it. Expose it with the following command: ```bash kubectl port-forward svc/demo-1 8888:80 ``` If this step was successful, you could try visiting , and you should see the Nginx hello message. This was just a simple example. There are more templates for you to explore, and you could try creating your own. If an error pops up referencing [the Kubernetes naming convention](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/), try conforming to the following rules: [x] contain no more than 63 characters [x] contain only lowercase alphanumeric characters or '-' [x] start with an alphanumeric character [x] end with an alphanumeric character If you are using your own template, be sure that you connected it correctly. This usually means that you didn't input the right `url + path + version`. When connecting the template to Cyclops, you need to copy the URL from the GitHub repository that leads to the template. The URL must lead to a directory that holds a `template` folder. In our example, we filled the form with the values below: ```yaml repository: https://github.com/cyclops-ui/templates path: demo version: main ``` Try connecting it again in the `Templates` tab. :::warning Private repositories are not yet supported! This is currently a high priority on our roadmap, and you should expect support for private repositories sooner rather than later. :::