text:
SUMMARY = "File classification tool"
DESCRIPTION = "File attempts to classify files depending \
on their contents and prints a description if a match is found."
HOMEPAGE = "http://www.darwinsys.com/file/"
SECTION = "console/utils"

# two clause BSD
LICENSE = "BSD"
LIC_FILES_CHKSUM = "file://COPYING;beginline=2;md5=6a7382872edb68d33e1a9398b6e03188"

#SRC_URI[md5sum] = "618e54d4baa11e5c8037fb3dd6650126"
#SRC_URI[sha256sum] = "a829d807e1f86eb1ffe9e895de401c69cc0af068b6930870e27f4956fa5b1666"

DEPENDS = "zlib file-replacement-native"
DEPENDS_class-native = "zlib-native"

#SRC_URI = "https://github.com/file/file.git"
SRC_URI = "git://github.com/file/file.git"

#SRCREV = "3c0874be4d3232d672b20f513451a39cfd7c585a"
#SRCREV = "ea2cd50d09bfc02ebbd066cad91f1883aba9a3ac"
SRCREV = "daaf6d44768677aca17af780bba0a451fbb69ac8"
S = "${WORKDIR}/git"

inherit autotools

EXTRA_OEMAKE_append_class-target = "-e FILE_COMPILE=${STAGING_BINDIR_NATIVE}/file-native/file"
EXTRA_OEMAKE_append_class-nativesdk = "-e FILE_COMPILE=${STAGING_BINDIR_NATIVE}/file-native/file"

FILES_${PN} += "${datadir}/misc/*.mgc"

do_install_append_class-native() {
	create_cmdline_wrapper ${D}/${bindir}/file \
		--magic-file ${datadir}/misc/magic.mgc
}

do_install_append_class-nativesdk() {
	create_cmdline_wrapper ${D}/${bindir}/file \
		--magic-file ${datadir}/misc/magic.mgc
}

BBCLASSEXTEND = "native nativesdk"
PROVIDES_append_class-native = " file-replacement-native"
# Don't use NATIVE_PACKAGE_PATH_SUFFIX as that hides libmagic from anyone who
# depends on file-replacement-native.
bindir_append_class-native = "/file-native"


text:
#
# This file is the dma-proxy-test recipe.
#

SUMMARY = "Simple dma-proxy-test application"
SECTION = "PETALINUX/apps"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"

SRC_URI = "file://dma-proxy.h \
           file://dma-proxy-test.c \
		   file://Makefile \
	"

S = "${WORKDIR}"
CFLAGS_prepend = "-I ${S}/include"
do_compile() {
        oe_runmake
}

do_install() {
	     install -d ${D}/${bindir}
	     install -m 0755 ${S}/dma-proxy-test ${D}/${bindir}
}

license: MIT

license_type: permissive

branch_name: refs/heads/main

extension: bb


text:
SUMMARY = "Simple local storage wrapper to save data on the browser side."
HOMEPAGE = "www.jstorage.info"

LICENSE = "PD"
LIC_FILES_CHKSUM = "file://${WORKDIR}/${BPN}/jstorage.js;beginline=1;endline=35;md5=b2c016f73a27b6855ecd0d427c3ce995"

DEPENDS = "jquery"

SRC_URI = "https://files.rce.systems/yocto-elite/jstorage-0.4.12.tar.gz"
SRC_URI[md5sum] = "28ae6e0b99823d52efb72af0ceceb4ae"
SRC_URI[sha256sum] = "6379dd04a595d5f5bc8b70a22d2991425fc215b798c95ad0e2647bd3aeee1cd0"

PROVIDES += " jstorage"
RPROVIDES_${PN} = "jstorage"

do_install() {
  install -d ${D}/src/htmllib/${BPN}/
  cp -r ${WORKDIR}/${BPN} ${D}/src/htmllib/
}

PACKAGES = "${PN}"
FILES_${PN} = "/src /src/htmllib /src/htmllib/${BPN}/*"

repository: RceSystems/meta-resptech-elite

repo_name: RceSystems/meta-resptech-elite

branch_name: refs/heads/master


text:
// Copyright 2019 Chaos Mesh 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,
// See the License for the specific language governing permissions and
// limitations under the License.

package v1alpha1

import (
	"time"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime"
	ctrl "sigs.k8s.io/controller-runtime"
)

const (
	// PauseAnnotationKey defines the annotation used to pause a chaos
	PauseAnnotationKey = "experiment.chaos-mesh.org/pause"
)

// LabelSelectorRequirements is list of LabelSelectorRequirement
type LabelSelectorRequirements []metav1.LabelSelectorRequirement

// +kubebuilder:object:generate=false

// SelectSpec defines a common interface for selector
type SelectSpec interface {
	GetSelector() SelectorSpec
	GetMode() PodMode
	GetValue() string
}

// SelectorSpec defines the some selectors to select objects.
// If the all selectors are empty, all objects will be used in chaos experiment.
type SelectorSpec struct {
	// Namespaces is a set of namespace to which objects belong.
	// +optional
	Namespaces []string `json:"namespaces,omitempty"`

	// Nodes is a set of node name and objects must belong to these nodes.
	// +optional
	Nodes []string `json:"nodes,omitempty"`

	// Pods is a map of string keys and a set values that used to select pods.
	// The key defines the namespace which pods belong,
	// and the each values is a set of pod names.
	// +optional
	Pods map[string][]string `json:"pods,omitempty"`

	// Map of string keys and values that can be used to select nodes.
	// Selector which must match a node's labels,
	// and objects must belong to these selected nodes.
	// +optional
	NodeSelectors map[string]string `json:"nodeSelectors,omitempty"`

	// Map of string keys and values that can be used to select objects.
	// A selector based on fields.
	// +optional
	FieldSelectors map[string]string `json:"fieldSelectors,omitempty"`

	// Map of string keys and values that can be used to select objects.
	// A selector based on labels.
	// +optional
	LabelSelectors map[string]string `json:"labelSelectors,omitempty"`

	// a slice of label selector expressions that can be used to select objects.
	// A list of selectors based on set-based label expressions.
	// +optional
	ExpressionSelectors LabelSelectorRequirements `json:"expressionSelectors,omitempty"`

	// Map of string keys and values that can be used to select objects.
	// A selector based on annotations.
	// +optional
	AnnotationSelectors map[string]string `json:"annotationSelectors,omitempty"`

	// PodPhaseSelectors is a set of condition of a pod at the current time.
	// supported value: Pending / Running / Succeeded / Failed / Unknown
	// +optional
	PodPhaseSelectors []string `json:"podPhaseSelectors,omitempty"`
}

// ClusterScoped returns true if the selector selects Pods in the cluster
func (s SelectorSpec) ClusterScoped() bool {
	// in fact, this will never happened, will add namespace if it is empty, so len(s.Namespaces) can not be 0,
	// but still add judgentment here for safe
	// https://github.com/chaos-mesh/chaos-mesh/blob/478d00d01bb0f9fb08a1085428a7da8c8f9df4e8/api/v1alpha1/common_webhook.go#L22
	if len(s.Namespaces) == 0 && len(s.Pods) == 0 {
		return true
	}

	return false
}

// AffectedNamespaces returns all the namespaces which the selector effect
func (s SelectorSpec) AffectedNamespaces() []string {
	affectedNamespacesMap := make(map[string]struct{})
	affectedNamespacesArray := make([]string, 0, 2)

	for namespace := range s.Pods {
		affectedNamespacesMap[namespace] = struct{}{}
	}

	for _, namespace := range s.Namespaces {
		affectedNamespacesMap[namespace] = struct{}{}
	}

	for namespace := range affectedNamespacesMap {
		affectedNamespacesArray = append(affectedNamespacesArray, namespace)
	}

	return affectedNamespacesArray
}

// SchedulerSpec defines information about schedule of the chaos experiment.
type SchedulerSpec struct {
	// Cron defines a cron job rule.
	//
	// Some rule examples:
	// "0 30 * * * *" means to "Every hour on the half hour"
	// "@hourly"      means to "Every hour"
	// "@every 1h30m" means to "Every hour thirty"
	//
	// More rule info: https://godoc.org/github.com/robfig/cron
	Cron string `json:"cron"`
}

// PodMode represents the mode to run pod chaos action.
type PodMode string

const (
	// OnePodMode represents that the system will do the chaos action on one pod selected randomly.
	OnePodMode PodMode = "one"
	// AllPodMode represents that the system will do the chaos action on all pods
	// regardless of status (not ready or not running pods includes).
	// Use this label carefully.
	AllPodMode PodMode = "all"
	// FixedPodMode represents that the system will do the chaos action on a specific number of running pods.
	FixedPodMode PodMode = "fixed"
	// FixedPercentPodMode to specify a fixed % that can be inject chaos action.
	FixedPercentPodMode PodMode = "fixed-percent"
	// RandomMaxPercentPodMode to specify a maximum % that can be inject chaos action.
	RandomMaxPercentPodMode PodMode = "random-max-percent"
)

// ChaosPhase is the current status of chaos task.
type ChaosPhase string

const (
	ChaosPhaseNone     ChaosPhase = ""
	ChaosPhaseNormal   ChaosPhase = "Normal"
	ChaosPhaseAbnormal ChaosPhase = "Abnormal"
)

type ChaosStatus struct {
	FailedMessage string `json:"failedMessage,omitempty"`

	Scheduler ScheduleStatus `json:"scheduler,omitempty"`

	// Experiment records the last experiment state.
	Experiment ExperimentStatus `json:"experiment"`
}

func (in *ChaosStatus) GetNextStart() time.Time {
	if in.Scheduler.NextStart == nil {
		return time.Time{}
	}
	return in.Scheduler.NextStart.Time
}

func (in *ChaosStatus) SetNextStart(t time.Time) {
	if t.IsZero() {
		in.Scheduler.NextStart = nil
		return
	}

	if in.Scheduler.NextStart == nil {
		in.Scheduler.NextStart = &metav1.Time{}
	}
	in.Scheduler.NextStart.Time = t
}

func (in *ChaosStatus) GetNextRecover() time.Time {
	if in.Scheduler.NextRecover == nil {
		return time.Time{}
	}
	return in.Scheduler.NextRecover.Time
}

func (in *ChaosStatus) SetNextRecover(t time.Time) {
	if t.IsZero() {
		in.Scheduler.NextRecover = nil
		return
	}

	if in.Scheduler.NextRecover == nil {
		in.Scheduler.NextRecover = &metav1.Time{}
	}
	in.Scheduler.NextRecover.Time = t
}

// ScheduleStatus is the current status of chaos scheduler.
type ScheduleStatus struct {
	// Next time when this action will be applied again
	// +optional
	NextStart *metav1.Time `json:"nextStart,omitempty"`

	// Next time when this action will be recovered
	// +optional
	NextRecover *metav1.Time `json:"nextRecover,omitempty"`
}

// ExperimentPhase is the current status of chaos experiment.
type ExperimentPhase string

const (
	ExperimentPhaseUninitialized ExperimentPhase = ""
	ExperimentPhaseRunning       ExperimentPhase = "Running"
	ExperimentPhaseWaiting       ExperimentPhase = "Waiting"
	ExperimentPhasePaused        ExperimentPhase = "Paused"
	ExperimentPhaseFailed        ExperimentPhase = "Failed"
	ExperimentPhaseFinished      ExperimentPhase = "Finished"
)

type ExperimentStatus struct {
	// +optional
	Phase ExperimentPhase `json:"phase,omitempty"`
	// +optional
	Reason string `json:"reason,omitempty"`
	// +optional
	StartTime *metav1.Time `json:"startTime,omitempty"`
	// +optional
	EndTime *metav1.Time `json:"endTime,omitempty"`
	// +optional
	Duration string `json:"duration,omitempty"`
	// +optional
	PodRecords []PodStatus `json:"podRecords,omitempty"`
}

var log = ctrl.Log.WithName("validate-webhook")

// +kubebuilder:object:generate=false

// InnerSchedulerObject is the Object for the twophase reconcile
type InnerSchedulerObject interface {
	InnerObject
	GetDuration() (*time.Duration, error)

	GetNextStart() time.Time
	SetNextStart(time.Time)

	GetNextRecover() time.Time
	SetNextRecover(time.Time)

	GetScheduler() *SchedulerSpec
}

// +kubebuilder:object:generate=false

// InnerObject is basic Object for the Reconciler
type InnerObject interface {
	IsDeleted() bool
	IsPaused() bool
	GetChaos() *ChaosInstance
	GetSpecAndMetaString() (string, error)
	StatefulObject
}

// +kubebuilder:object:generate=false

// StatefulObject defines a basic Object that can get the status
type StatefulObject interface {
	runtime.Object
	GetStatus() *ChaosStatus
}

// +kubebuilder:object:generate=false

// ChaosInstance defines some common attribute for a chaos
type ChaosInstance struct {
	Name      string
	Namespace string
	Kind      string
	StartTime time.Time
	EndTime   time.Time
	Action    string
	Duration  string
	Status    string
	UID       string
}

// +kubebuilder:object:generate=false

// ChaosList defines a common interface for chaos lists
type ChaosList interface {
	runtime.Object
	ListChaos() []*ChaosInstance
}

gha_language: Go

extension: go


text:
/*
Copyright 2017 The Kubernetes 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.
*/

package google

import (
	"fmt"
	"github.com/golang/glog"
	"os/exec"
)

const (
	MachineControllerServiceAccount = "k8s-machine-controller"
	MachineControllerSecret         = "machine-controller-credential"
)

// Creates a GCP service account for the machine controller, granted the
// permissions to manage compute instances, and stores its credentials as a
// Kubernetes secret.
func CreateMachineControllerServiceAccount(projects []string) error {
	// TODO: use real go bindings

	// The service account needs to be created in a single project, so just
	// use the first one, but grant permission to all projects in the list.
	project := projects[0]

	err := run("gcloud", "--project", project, "iam", "service-accounts", "create", "--display-name=k8s machines controller", MachineControllerServiceAccount)
	if err != nil {
		return fmt.Errorf("couldn't create service account: %v", err)
	}

	email := accountId(project)
	localFile := MachineControllerServiceAccount + "-key.json"

	for _, project := range projects {
		err = run("gcloud", "projects", "add-iam-policy-binding", project, "--member=serviceAccount:"+email, "--role=roles/compute.instanceAdmin.v1")
		if err != nil {
			return fmt.Errorf("couldn't grant permissions to service account: %v", err)
		}
	}

	err = run("gcloud", "--project", project, "iam", "service-accounts", "keys", "create", localFile, "--iam-account", email)
	if err != nil {
		return fmt.Errorf("couldn't create service account key: %v", err)
	}

	err = run("kubectl", "create", "secret", "generic", "-n", "kube-system", MachineControllerSecret, "--from-file=service-account.json="+localFile)
	if err != nil {
		return fmt.Errorf("couldn't import service account key as credential: %v", err)
	}
	if err := run("rm", localFile); err != nil {
		glog.Error(err)
	}
	return nil
}

func DeleteMachineControllerServiceAccount(projects []string) error {
	project := projects[0]

	email := accountId(project)
	err := run("gcloud", "projects", "remove-iam-policy-binding", project, "--member=serviceAccount:"+email, "--role=roles/compute.instanceAdmin.v1")

	if err != nil {
		return fmt.Errorf("couldn't remove permissions to service account: %v", err)
	}

	err = run("gcloud", "--project", project, "iam", "service-accounts", "delete", email)
	if err != nil {
		return fmt.Errorf("couldn't delete service account: %v", err)
	}
	return nil
}

func accountId(project string) string {
	return fmt.Sprintf("%s@%s.iam.gserviceaccount.com", MachineControllerServiceAccount, project)
}

func run(cmd string, args ...string) error {
	c := exec.Command(cmd, args...)
	if out, err := c.CombinedOutput(); err != nil {
		return fmt.Errorf("error: %v, output: %s", err, string(out))
	}
	return nil
}

repository: krisnova/kube-deploy

repo_name: krisnova/kube-deploy


text:
package cmd

import (
	"errors"
	"fmt"
	"strings"
	"time"

	"github.com/spf13/cobra"

	"github.com/exoscale/cli/pkg/account"
	"github.com/exoscale/cli/pkg/globalstate"
	"github.com/exoscale/cli/pkg/output"
	egoscale "github.com/exoscale/egoscale/v2"
	exoapi "github.com/exoscale/egoscale/v2/api"
)

type elasticIPUpdateCmd struct {
	cliCommandSettings `cli-cmd:"-"`

	_ bool `cli-cmd:"update"`

	ElasticIP string `cli-arg:"#" cli-usage:"IP-ADDRESS|ID"`

	Description               string `cli-usage:"Elastic IP description"`
	HealthcheckInterval       int64  `cli-usage:"managed Elastic IP health checking interval in seconds"`
	HealthcheckMode           string `cli-usage:"managed Elastic IP health checking mode (tcp|http|https)"`
	HealthcheckPort           int64  `cli-usage:"managed Elastic IP health checking port"`
	HealthcheckStrikesFail    int64  `cli-usage:"number of failed attempts before considering a managed Elastic IP health check unhealthy"`
	HealthcheckStrikesOK      int64  `cli-usage:"number of successful attempts before considering a managed Elastic IP health check healthy"`
	HealthcheckTLSSNI         string `cli-flag:"healthcheck-tls-sni" cli-usage:"managed Elastic IP health checking server name to present with SNI in https mode"`
	HealthcheckTLSSSkipVerify bool   `cli-flag:"healthcheck-tls-skip-verify" cli-usage:"disable TLS certificate verification for managed Elastic IP health checking in https mode"`
	HealthcheckTimeout        int64  `cli-usage:"managed Elastic IP health checking timeout in seconds"`
	HealthcheckURI            string `cli-usage:"managed Elastic IP health checking URI (required in http(s) mode)"`
	Zone                      string `cli-short:"z" cli-usage:"Elastic IP zone"`
	ReverseDNS                string `cli-usage:"Reverse DNS Domain"`
}

func (c *elasticIPUpdateCmd) cmdAliases() []string { return nil }

func (c *elasticIPUpdateCmd) cmdShort() string {
	return "Update an Elastic IP"
}

func (c *elasticIPUpdateCmd) cmdLong() string {
	return fmt.Sprintf(`This command updates a Compute instance Elastic IP.

Supported output template annotations: %s`,
		strings.Join(output.TemplateAnnotations(&elasticIPShowOutput{}), ", "))
}

func (c *elasticIPUpdateCmd) cmdPreRun(cmd *cobra.Command, args []string) error {
	cmdSetZoneFlagFromDefault(cmd)
	return cliCommandDefaultPreRun(c, cmd, args)
}

func (c *elasticIPUpdateCmd) cmdRun(cmd *cobra.Command, _ []string) error {
	var updatedInstance, updatedRDNS bool

	ctx := exoapi.WithEndpoint(gContext, exoapi.NewReqEndpoint(account.CurrentAccount.Environment, c.Zone))

	elasticIP, err := globalstate.EgoscaleClient.FindElasticIP(ctx, c.Zone, c.ElasticIP)
	if err != nil {
		if errors.Is(err, exoapi.ErrNotFound) {
			return fmt.Errorf("resource not found in zone %q", c.Zone)
		}
		return err
	}

	if cmd.Flags().Changed(mustCLICommandFlagName(c, &c.Description)) {
		elasticIP.Description = &c.Description
		updatedInstance = true
	}

	if cmd.Flags().Changed(mustCLICommandFlagName(c, &c.HealthcheckMode)) {
		if elasticIP.Healthcheck == nil {
			elasticIP.Healthcheck = new(egoscale.ElasticIPHealthcheck)
		}
		elasticIP.Healthcheck.Mode = &c.HealthcheckMode
		updatedInstance = true
	}

	if cmd.Flags().Changed(mustCLICommandFlagName(c, &c.ReverseDNS)) {
		updatedRDNS = true
	}

	for _, flag := range []string{
		mustCLICommandFlagName(c, &c.HealthcheckInterval),
		mustCLICommandFlagName(c, &c.HealthcheckPort),
		mustCLICommandFlagName(c, &c.HealthcheckStrikesFail),
		mustCLICommandFlagName(c, &c.HealthcheckStrikesOK),
		mustCLICommandFlagName(c, &c.HealthcheckTLSSNI),
		mustCLICommandFlagName(c, &c.HealthcheckTLSSSkipVerify),
		mustCLICommandFlagName(c, &c.HealthcheckTimeout),
		mustCLICommandFlagName(c, &c.HealthcheckURI),
	} {
		if cmd.Flags().Changed(flag) && elasticIP.Healthcheck == nil {
			return fmt.Errorf("--%s cannot be used on a non-managed Elastic IP", flag)
		}
	}

	if flag := mustCLICommandFlagName(c, &c.HealthcheckInterval); cmd.Flags().Changed(flag) {
		interval := time.Duration(c.HealthcheckInterval) * time.Second
		elasticIP.Healthcheck.Interval = &interval
		updatedInstance = true
	}

	if flag := mustCLICommandFlagName(c, &c.HealthcheckPort); cmd.Flags().Changed(flag) {
		port := uint16(c.HealthcheckPort)
		elasticIP.Healthcheck.Port = &port
		updatedInstance = true
	}

	if flag := mustCLICommandFlagName(c, &c.HealthcheckStrikesFail); cmd.Flags().Changed(flag) {
		elasticIP.Healthcheck.StrikesFail = &c.HealthcheckStrikesFail
		updatedInstance = true
	}

	if flag := mustCLICommandFlagName(c, &c.HealthcheckStrikesOK); cmd.Flags().Changed(flag) {
		elasticIP.Healthcheck.StrikesOK = &c.HealthcheckStrikesOK
		updatedInstance = true
	}

	if flag := mustCLICommandFlagName(c, &c.HealthcheckStrikesOK); cmd.Flags().Changed(flag) {
		elasticIP.Healthcheck.StrikesOK = &c.HealthcheckStrikesOK
		updatedInstance = true
	}

	if elasticIP.Healthcheck != nil && *elasticIP.Healthcheck.Mode == "https" {
		if flag := mustCLICommandFlagName(c, &c.HealthcheckTLSSSkipVerify); cmd.Flags().Changed(flag) {
			elasticIP.Healthcheck.TLSSkipVerify = &c.HealthcheckTLSSSkipVerify
			updatedInstance = true
		}

		if flag := mustCLICommandFlagName(c, &c.HealthcheckTLSSNI); cmd.Flags().Changed(flag) {
			elasticIP.Healthcheck.TLSSNI = &c.HealthcheckTLSSNI
			updatedInstance = true
		}
	}

	if flag := mustCLICommandFlagName(c, &c.HealthcheckTimeout); cmd.Flags().Changed(flag) {
		timeout := time.Duration(c.HealthcheckTimeout) * time.Second
		elasticIP.Healthcheck.Timeout = &timeout
		updatedInstance = true
	}

	if flag := mustCLICommandFlagName(c, &c.HealthcheckURI); cmd.Flags().Changed(flag) {
		elasticIP.Healthcheck.URI = &c.HealthcheckURI
		updatedInstance = true
	}

	if updatedInstance || updatedRDNS {
		decorateAsyncOperation(fmt.Sprintf("Updating Elastic IP %s...", c.ElasticIP), func() {
			if updatedInstance {
				if err = globalstate.EgoscaleClient.UpdateElasticIP(ctx, c.Zone, elasticIP); err != nil {
					return
				}
			}

			if updatedRDNS {
				if c.ReverseDNS == "" {
					err = globalstate.EgoscaleClient.DeleteElasticIPReverseDNS(ctx, c.Zone, *elasticIP.ID)
				} else {
					err = globalstate.EgoscaleClient.UpdateElasticIPReverseDNS(ctx, c.Zone, *elasticIP.ID, c.ReverseDNS)
				}
			}
		})

		if err != nil {
			return err
		}
	}

	if !globalstate.Quiet {
		return (&elasticIPShowCmd{
			cliCommandSettings: c.cliCommandSettings,
			ElasticIP:          *elasticIP.ID,
			Zone:               c.Zone,
		}).cmdRun(nil, nil)
	}

	return nil
}

func init() {
	cobra.CheckErr(registerCLICommand(elasticIPCmd, &elasticIPUpdateCmd{
		cliCommandSettings: defaultCLICmdSettings(),
	}))
}

repository: exoscale/cli

repo_name: exoscale/cli


text:
SUMMARY = "Websocket C library"
HOMEPAGE = "https://libwebsockets.org"
MAINTAINER = "Robert Lehmann <robert.lehmann@sitec-systems.de>"

LICENSE = "LGPLv2"
LIC_FILES_CHKSUM = "file://LICENSE;md5=4ce87f3facb6f911c142c8bef9bfb380"

DEPENDS_${PN} = "openssl"
RDEPENDS_${PN} = "libcap openssl"

PR = "r0"

SRC_URI = "https://github.com/warmcat/libwebsockets/archive/v${PV}.zip"
SRC_URI[md5sum] = "72da65198e8137c5ba1468d219408d94"
SRC_URI[sha256sum] = "0fd3c2bcd5de7b45ac2f54542da39798259d10d53ce5878bdca7071f985073f3"

inherit cmake

FILES_${PN}-dev += "/usr/lib/cmake"
FILES_${PN}-doc += "/usr/share"


text:
inherit esw_examples features_check

REQUIRED_MACHINE_FEATURES = "ospipsv"

ESW_COMPONENT_SRC = "/XilinxProcessorIPLib/drivers/ospipsv/examples/"

repository: Xilinx/meta-xilinx

repo_name: Xilinx/meta-xilinx

gha_license_id: MIT

gha_language: C


text:
# Copyright (c) 2012-2014 LG Electronics, Inc.

SUMMARY = "Provides image manipulation, preference, timezone and ringtone services for Open webOS components"
AUTHOR = "Keith Derrick <keith.derrick@lge.com>"
SECTION = "webos/base"
LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/Apache-2.0;md5=89aea4e17d99a7cacdbeed46a0096b10"

VIRTUAL-RUNTIME_ntp ?= "sntp"

DEPENDS = "luna-service2 libpbnjson qtbase uriparser libxml2 sqlite3 pmloglib json-c nyx-lib"

RDEPENDS_${PN} += "${VIRTUAL-RUNTIME_ntp}"

PV = "2.0.1-38+git${SRCPV}"
SRCREV = "309b1268f83f896b547e70e409bfc77eed717288"

inherit webos_ports_fork_repo
inherit webos_cmake
inherit webos_system_bus
inherit pkgconfig
inherit webos_systemd

SRC_URI = "${WEBOS_PORTS_GIT_REPO_COMPLETE}"
S = "${WORKDIR}/git"

repository: webOSCE-ports/meta-webos-ports

repo_name: webOSCE-ports/meta-webos-ports


text:
@article{Tsallis:2007:GeneralizedBoxMuller,
  author = {Thistleton, W. J. and Marsh, J. A. and Nelson, K. and Tsallis, C.},
  title = {Generalized Box-Müller Method for Generating q-Gaussian Random Deviates},
  journal = {IEEE Trans. Inf. Theor.},
  issue_date = {December 2007},
  volume = {53},
  number = {12},
  month = dec,
  year = {2007},
  issn = {0018-9448},
  pages = {4805--4810},
  numpages = {6},
  doi = {10.1109/TIT.2007.909173},
  acmid = {2273064},
  publisher = {IEEE Press},
  address = {Piscataway, NJ, USA},
}

@book{Press:Numerical:Recipes,
  Author = {William H. Press},
  Title = {Numerical Recipes},
  Publisher = {Cambridge University Press},
  Year = {2007},
  ISBN = {0521880688},
}

@book{Sayama:2015:ComplexSystems,
	edition = {1st},
	title = {Introduction to the Modeling and Analysis of Complex Systems},
	isbn = {978-1-942341-09-3},
	url = {http://textbooks.opensuny.org/introduction-to-the-modeling-and-analysis-of-complex-systems/},
	language = {English},
	urldate = {2016-08-08},
	publisher = {Binghamton University, Suny},
	author = {{Hiroki Sayama}},
	year = {2015},
}

extension: bib